/// Type of information detected by the API.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InfoType {
    /// Name of the information type. Either a name of your choosing when
    /// creating a CustomInfoType, or one of the names listed
    /// at <https://cloud.google.com/dlp/docs/infotypes-reference> when specifying
    /// a built-in type.  When sending Cloud DLP results to Data Catalog, infoType
    /// names should conform to the pattern `\[A-Za-z0-9$-_\]{1,64}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A reference to a StoredInfoType to use with scanning.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StoredType {
    /// Resource name of the requested `StoredInfoType`, for example
    /// `organizations/433245324/storedInfoTypes/432452342` or
    /// `projects/project-id/storedInfoTypes/432452342`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Timestamp indicating when the version of the `StoredInfoType` used for
    /// inspection was created. Output-only field, populated by the system.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Custom information type provided by the user. Used to find domain-specific
/// sensitive information configurable to the data in question.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomInfoType {
    /// CustomInfoType can either be a new infoType, or an extension of built-in
    /// infoType, when the name matches one of existing infoTypes and that infoType
    /// is specified in `InspectContent.info_types` field. Specifying the latter
    /// adds findings to the one detected by the system. If built-in info type is
    /// not specified in `InspectContent.info_types` list then the name is treated
    /// as a custom info type.
    #[prost(message, optional, tag = "1")]
    pub info_type: ::core::option::Option<InfoType>,
    /// Likelihood to return for this CustomInfoType. This base value can be
    /// altered by a detection rule if the finding meets the criteria specified by
    /// the rule. Defaults to `VERY_LIKELY` if not specified.
    #[prost(enumeration = "Likelihood", tag = "6")]
    pub likelihood: i32,
    /// Set of detection rules to apply to all findings of this CustomInfoType.
    /// Rules are applied in order that they are specified. Not supported for the
    /// `surrogate_type` CustomInfoType.
    #[prost(message, repeated, tag = "7")]
    pub detection_rules: ::prost::alloc::vec::Vec<custom_info_type::DetectionRule>,
    /// If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
    /// to be returned. It still can be used for rules matching.
    #[prost(enumeration = "custom_info_type::ExclusionType", tag = "8")]
    pub exclusion_type: i32,
    #[prost(oneof = "custom_info_type::Type", tags = "2, 3, 4, 5")]
    pub r#type: ::core::option::Option<custom_info_type::Type>,
}
/// Nested message and enum types in `CustomInfoType`.
pub mod custom_info_type {
    /// Custom information type based on a dictionary of words or phrases. This can
    /// be used to match sensitive information specific to the data, such as a list
    /// of employee IDs or job titles.
    ///
    /// Dictionary words are case-insensitive and all characters other than letters
    /// and digits in the unicode [Basic Multilingual
    /// Plane](<https://en.wikipedia.org/wiki/Plane_%28Unicode%29#Basic_Multilingual_Plane>)
    /// will be replaced with whitespace when scanning for matches, so the
    /// dictionary phrase "Sam Johnson" will match all three phrases "sam johnson",
    /// "Sam, Johnson", and "Sam (Johnson)". Additionally, the characters
    /// surrounding any match must be of a different type than the adjacent
    /// characters within the word, so letters must be next to non-letters and
    /// digits next to non-digits. For example, the dictionary word "jen" will
    /// match the first three letters of the text "jen123" but will return no
    /// matches for "jennifer".
    ///
    /// Dictionary words containing a large number of characters that are not
    /// letters or digits may result in unexpected findings because such characters
    /// are treated as whitespace. The
    /// \[limits\](<https://cloud.google.com/dlp/limits>) page contains details about
    /// the size limits of dictionaries. For dictionaries that do not fit within
    /// these constraints, consider using `LargeCustomDictionaryConfig` in the
    /// `StoredInfoType` API.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Dictionary {
        #[prost(oneof = "dictionary::Source", tags = "1, 3")]
        pub source: ::core::option::Option<dictionary::Source>,
    }
    /// Nested message and enum types in `Dictionary`.
    pub mod dictionary {
        /// Message defining a list of words or phrases to search for in the data.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct WordList {
            /// Words or phrases defining the dictionary. The dictionary must contain
            /// at least one phrase and every phrase must contain at least 2 characters
            /// that are letters or digits. \[required\]
            #[prost(string, repeated, tag = "1")]
            pub words: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Source {
            /// List of words or phrases to search for.
            #[prost(message, tag = "1")]
            WordList(WordList),
            /// Newline-delimited file of words in Cloud Storage. Only a single file
            /// is accepted.
            #[prost(message, tag = "3")]
            CloudStoragePath(super::super::CloudStoragePath),
        }
    }
    /// Message defining a custom regular expression.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Regex {
        /// Pattern defining the regular expression. Its syntax
        /// (<https://github.com/google/re2/wiki/Syntax>) can be found under the
        /// google/re2 repository on GitHub.
        #[prost(string, tag = "1")]
        pub pattern: ::prost::alloc::string::String,
        /// The index of the submatch to extract as findings. When not
        /// specified, the entire match is returned. No more than 3 may be included.
        #[prost(int32, repeated, tag = "2")]
        pub group_indexes: ::prost::alloc::vec::Vec<i32>,
    }
    /// Message for detecting output from deidentification transformations
    /// such as
    /// \[`CryptoReplaceFfxFpeConfig`\](<https://cloud.google.com/dlp/docs/reference/rest/v2/organizations.deidentifyTemplates#cryptoreplaceffxfpeconfig>).
    /// These types of transformations are
    /// those that perform pseudonymization, thereby producing a "surrogate" as
    /// output. This should be used in conjunction with a field on the
    /// transformation such as `surrogate_info_type`. This CustomInfoType does
    /// not support the use of `detection_rules`.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SurrogateType {}
    /// Deprecated; use `InspectionRuleSet` instead. Rule for modifying a
    /// `CustomInfoType` to alter behavior under certain circumstances, depending
    /// on the specific details of the rule. Not supported for the `surrogate_type`
    /// custom infoType.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DetectionRule {
        #[prost(oneof = "detection_rule::Type", tags = "1")]
        pub r#type: ::core::option::Option<detection_rule::Type>,
    }
    /// Nested message and enum types in `DetectionRule`.
    pub mod detection_rule {
        /// Message for specifying a window around a finding to apply a detection
        /// rule.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Proximity {
            /// Number of characters before the finding to consider.
            #[prost(int32, tag = "1")]
            pub window_before: i32,
            /// Number of characters after the finding to consider.
            #[prost(int32, tag = "2")]
            pub window_after: i32,
        }
        /// Message for specifying an adjustment to the likelihood of a finding as
        /// part of a detection rule.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct LikelihoodAdjustment {
            #[prost(oneof = "likelihood_adjustment::Adjustment", tags = "1, 2")]
            pub adjustment: ::core::option::Option<likelihood_adjustment::Adjustment>,
        }
        /// Nested message and enum types in `LikelihoodAdjustment`.
        pub mod likelihood_adjustment {
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Adjustment {
                /// Set the likelihood of a finding to a fixed value.
                #[prost(enumeration = "super::super::super::Likelihood", tag = "1")]
                FixedLikelihood(i32),
                /// Increase or decrease the likelihood by the specified number of
                /// levels. For example, if a finding would be `POSSIBLE` without the
                /// detection rule and `relative_likelihood` is 1, then it is upgraded to
                /// `LIKELY`, while a value of -1 would downgrade it to `UNLIKELY`.
                /// Likelihood may never drop below `VERY_UNLIKELY` or exceed
                /// `VERY_LIKELY`, so applying an adjustment of 1 followed by an
                /// adjustment of -1 when base likelihood is `VERY_LIKELY` will result in
                /// a final likelihood of `LIKELY`.
                #[prost(int32, tag = "2")]
                RelativeLikelihood(i32),
            }
        }
        /// The rule that adjusts the likelihood of findings within a certain
        /// proximity of hotwords.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct HotwordRule {
            /// Regular expression pattern defining what qualifies as a hotword.
            #[prost(message, optional, tag = "1")]
            pub hotword_regex: ::core::option::Option<super::Regex>,
            /// Proximity of the finding within which the entire hotword must reside.
            /// The total length of the window cannot exceed 1000 characters. Note that
            /// the finding itself will be included in the window, so that hotwords may
            /// be used to match substrings of the finding itself. For example, the
            /// certainty of a phone number regex "\(\d{3}\) \d{3}-\d{4}" could be
            /// adjusted upwards if the area code is known to be the local area code of
            /// a company office using the hotword regex "\(xxx\)", where "xxx"
            /// is the area code in question.
            #[prost(message, optional, tag = "2")]
            pub proximity: ::core::option::Option<Proximity>,
            /// Likelihood adjustment to apply to all matching findings.
            #[prost(message, optional, tag = "3")]
            pub likelihood_adjustment: ::core::option::Option<LikelihoodAdjustment>,
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// Hotword-based detection rule.
            #[prost(message, tag = "1")]
            HotwordRule(HotwordRule),
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum ExclusionType {
        /// A finding of this custom info type will not be excluded from results.
        Unspecified = 0,
        /// A finding of this custom info type will be excluded from final results,
        /// but can still affect rule execution.
        Exclude = 1,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// A list of phrases to detect as a CustomInfoType.
        #[prost(message, tag = "2")]
        Dictionary(Dictionary),
        /// Regular expression based CustomInfoType.
        #[prost(message, tag = "3")]
        Regex(Regex),
        /// Message for detecting output from deidentification transformations that
        /// support reversing.
        #[prost(message, tag = "4")]
        SurrogateType(SurrogateType),
        /// Load an existing `StoredInfoType` resource for use in
        /// `InspectDataSource`. Not currently supported in `InspectContent`.
        #[prost(message, tag = "5")]
        StoredType(super::StoredType),
    }
}
/// General identifier of a data field in a storage service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldId {
    /// Name describing the field.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Datastore partition ID.
/// A partition ID identifies a grouping of entities. The grouping is always
/// by project and namespace, however the namespace ID may be empty.
///
/// A partition ID contains several dimensions:
/// project ID and namespace ID.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionId {
    /// The ID of the project to which the entities belong.
    #[prost(string, tag = "2")]
    pub project_id: ::prost::alloc::string::String,
    /// If not empty, the ID of the namespace to which the entities belong.
    #[prost(string, tag = "4")]
    pub namespace_id: ::prost::alloc::string::String,
}
/// A representation of a Datastore kind.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KindExpression {
    /// The name of the kind.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Options defining a data set within Google Cloud Datastore.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatastoreOptions {
    /// A partition ID identifies a grouping of entities. The grouping is always
    /// by project and namespace, however the namespace ID may be empty.
    #[prost(message, optional, tag = "1")]
    pub partition_id: ::core::option::Option<PartitionId>,
    /// The kind to process.
    #[prost(message, optional, tag = "2")]
    pub kind: ::core::option::Option<KindExpression>,
}
/// Message representing a set of files in a Cloud Storage bucket. Regular
/// expressions are used to allow fine-grained control over which files in the
/// bucket to include.
///
/// Included files are those that match at least one item in `include_regex` and
/// do not match any items in `exclude_regex`. Note that a file that matches
/// items from both lists will _not_ be included. For a match to occur, the
/// entire file path (i.e., everything in the url after the bucket name) must
/// match the regular expression.
///
/// For example, given the input `{bucket_name: "mybucket", include_regex:
/// \["directory1/.*"\], exclude_regex:
/// \["directory1/excluded.*"\]}`:
///
/// * `gs://mybucket/directory1/myfile` will be included
/// * `gs://mybucket/directory1/directory2/myfile` will be included (`.*` matches
/// across `/`)
/// * `gs://mybucket/directory0/directory1/myfile` will _not_ be included (the
/// full path doesn't match any items in `include_regex`)
/// * `gs://mybucket/directory1/excludedfile` will _not_ be included (the path
/// matches an item in `exclude_regex`)
///
/// If `include_regex` is left empty, it will match all files by default
/// (this is equivalent to setting `include_regex: \[".*"\]`).
///
/// Some other common use cases:
///
/// * `{bucket_name: "mybucket", exclude_regex: \[".*\.pdf"\]}` will include all
/// files in `mybucket` except for .pdf files
/// * `{bucket_name: "mybucket", include_regex: \["directory/[^/]+"\]}` will
/// include all files directly under `gs://mybucket/directory/`, without matching
/// across `/`
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudStorageRegexFileSet {
    /// The name of a Cloud Storage bucket. Required.
    #[prost(string, tag = "1")]
    pub bucket_name: ::prost::alloc::string::String,
    /// A list of regular expressions matching file paths to include. All files in
    /// the bucket that match at least one of these regular expressions will be
    /// included in the set of files, except for those that also match an item in
    /// `exclude_regex`. Leaving this field empty will match all files by default
    /// (this is equivalent to including `.*` in the list).
    ///
    /// Regular expressions use RE2
    /// \[syntax\](<https://github.com/google/re2/wiki/Syntax>); a guide can be found
    /// under the google/re2 repository on GitHub.
    #[prost(string, repeated, tag = "2")]
    pub include_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A list of regular expressions matching file paths to exclude. All files in
    /// the bucket that match at least one of these regular expressions will be
    /// excluded from the scan.
    ///
    /// Regular expressions use RE2
    /// \[syntax\](<https://github.com/google/re2/wiki/Syntax>); a guide can be found
    /// under the google/re2 repository on GitHub.
    #[prost(string, repeated, tag = "3")]
    pub exclude_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Options defining a file or a set of files within a Google Cloud Storage
/// bucket.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudStorageOptions {
    /// The set of one or more files to scan.
    #[prost(message, optional, tag = "1")]
    pub file_set: ::core::option::Option<cloud_storage_options::FileSet>,
    /// Max number of bytes to scan from a file. If a scanned file's size is bigger
    /// than this value then the rest of the bytes are omitted. Only one
    /// of bytes_limit_per_file and bytes_limit_per_file_percent can be specified.
    #[prost(int64, tag = "4")]
    pub bytes_limit_per_file: i64,
    /// Max percentage of bytes to scan from a file. The rest are omitted. The
    /// number of bytes scanned is rounded down. Must be between 0 and 100,
    /// inclusively. Both 0 and 100 means no limit. Defaults to 0. Only one
    /// of bytes_limit_per_file and bytes_limit_per_file_percent can be specified.
    #[prost(int32, tag = "8")]
    pub bytes_limit_per_file_percent: i32,
    /// List of file type groups to include in the scan.
    /// If empty, all files are scanned and available data format processors
    /// are applied. In addition, the binary content of the selected files
    /// is always scanned as well.
    /// Images are scanned only as binary if the specified region
    /// does not support image inspection and no file_types were specified.
    /// Image inspection is restricted to 'global', 'us', 'asia', and 'europe'.
    #[prost(enumeration = "FileType", repeated, tag = "5")]
    pub file_types: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "cloud_storage_options::SampleMethod", tag = "6")]
    pub sample_method: i32,
    /// Limits the number of files to scan to this percentage of the input FileSet.
    /// Number of files scanned is rounded down. Must be between 0 and 100,
    /// inclusively. Both 0 and 100 means no limit. Defaults to 0.
    #[prost(int32, tag = "7")]
    pub files_limit_percent: i32,
}
/// Nested message and enum types in `CloudStorageOptions`.
pub mod cloud_storage_options {
    /// Set of files to scan.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FileSet {
        /// The Cloud Storage url of the file(s) to scan, in the format
        /// `gs://<bucket>/<path>`. Trailing wildcard in the path is allowed.
        ///
        /// If the url ends in a trailing slash, the bucket or directory represented
        /// by the url will be scanned non-recursively (content in sub-directories
        /// will not be scanned). This means that `gs://mybucket/` is equivalent to
        /// `gs://mybucket/*`, and `gs://mybucket/directory/` is equivalent to
        /// `gs://mybucket/directory/*`.
        ///
        /// Exactly one of `url` or `regex_file_set` must be set.
        #[prost(string, tag = "1")]
        pub url: ::prost::alloc::string::String,
        /// The regex-filtered set of files to scan. Exactly one of `url` or
        /// `regex_file_set` must be set.
        #[prost(message, optional, tag = "2")]
        pub regex_file_set: ::core::option::Option<super::CloudStorageRegexFileSet>,
    }
    /// How to sample bytes if not all bytes are scanned. Meaningful only when used
    /// in conjunction with bytes_limit_per_file. If not specified, scanning would
    /// start from the top.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum SampleMethod {
        Unspecified = 0,
        /// Scan from the top (default).
        Top = 1,
        /// For each file larger than bytes_limit_per_file, randomly pick the offset
        /// to start scanning. The scanned bytes are contiguous.
        RandomStart = 2,
    }
}
/// Message representing a set of files in Cloud Storage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudStorageFileSet {
    /// The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the
    /// path is allowed.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
/// Message representing a single file or path in Cloud Storage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudStoragePath {
    /// A url representing a file or path (no wildcards) in Cloud Storage.
    /// Example: gs://\[BUCKET_NAME\]/dictionary.txt
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
}
/// Options defining BigQuery table and row identifiers.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigQueryOptions {
    /// Complete BigQuery table reference.
    #[prost(message, optional, tag = "1")]
    pub table_reference: ::core::option::Option<BigQueryTable>,
    /// Table fields that may uniquely identify a row within the table. When
    /// `actions.saveFindings.outputConfig.table` is specified, the values of
    /// columns specified here are available in the output table under
    /// `location.content_locations.record_location.record_key.id_values`. Nested
    /// fields such as `person.birthdate.year` are allowed.
    #[prost(message, repeated, tag = "2")]
    pub identifying_fields: ::prost::alloc::vec::Vec<FieldId>,
    /// Max number of rows to scan. If the table has more rows than this value, the
    /// rest of the rows are omitted. If not set, or if set to 0, all rows will be
    /// scanned. Only one of rows_limit and rows_limit_percent can be specified.
    /// Cannot be used in conjunction with TimespanConfig.
    #[prost(int64, tag = "3")]
    pub rows_limit: i64,
    /// Max percentage of rows to scan. The rest are omitted. The number of rows
    /// scanned is rounded down. Must be between 0 and 100, inclusively. Both 0 and
    /// 100 means no limit. Defaults to 0. Only one of rows_limit and
    /// rows_limit_percent can be specified. Cannot be used in conjunction with
    /// TimespanConfig.
    #[prost(int32, tag = "6")]
    pub rows_limit_percent: i32,
    #[prost(enumeration = "big_query_options::SampleMethod", tag = "4")]
    pub sample_method: i32,
    /// References to fields excluded from scanning. This allows you to skip
    /// inspection of entire columns which you know have no findings.
    #[prost(message, repeated, tag = "5")]
    pub excluded_fields: ::prost::alloc::vec::Vec<FieldId>,
}
/// Nested message and enum types in `BigQueryOptions`.
pub mod big_query_options {
    /// How to sample rows if not all rows are scanned. Meaningful only when used
    /// in conjunction with either rows_limit or rows_limit_percent. If not
    /// specified, rows are scanned in the order BigQuery reads them.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum SampleMethod {
        Unspecified = 0,
        /// Scan groups of rows in the order BigQuery provides (default). Multiple
        /// groups of rows may be scanned in parallel, so results may not appear in
        /// the same order the rows are read.
        Top = 1,
        /// Randomly pick groups of rows to scan.
        RandomStart = 2,
    }
}
/// Shared message indicating Cloud storage type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageConfig {
    #[prost(message, optional, tag = "6")]
    pub timespan_config: ::core::option::Option<storage_config::TimespanConfig>,
    #[prost(oneof = "storage_config::Type", tags = "2, 3, 4, 9")]
    pub r#type: ::core::option::Option<storage_config::Type>,
}
/// Nested message and enum types in `StorageConfig`.
pub mod storage_config {
    /// Configuration of the timespan of the items to include in scanning.
    /// Currently only supported when inspecting Google Cloud Storage and BigQuery.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TimespanConfig {
        /// Exclude files, tables, or rows older than this value.
        /// If not set, no lower time limit is applied.
        #[prost(message, optional, tag = "1")]
        pub start_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Exclude files, tables, or rows newer than this value.
        /// If not set, no upper time limit is applied.
        #[prost(message, optional, tag = "2")]
        pub end_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Specification of the field containing the timestamp of scanned items.
        /// Used for data sources like Datastore and BigQuery.
        ///
        /// For BigQuery:
        /// If this value is not specified and the table was modified between the
        /// given start and end times, the entire table will be scanned. If this
        /// value is specified, then rows are filtered based on the given start and
        /// end times. Rows with a `NULL` value in the provided BigQuery column are
        /// skipped.
        /// Valid data types of the provided BigQuery column are: `INTEGER`, `DATE`,
        /// `TIMESTAMP`, and `DATETIME`.
        ///
        /// For Datastore:
        /// If this value is specified, then entities are filtered based on the given
        /// start and end times. If an entity does not contain the provided timestamp
        /// property or contains empty or invalid values, then it is included.
        /// Valid data types of the provided timestamp property are: `TIMESTAMP`.
        #[prost(message, optional, tag = "3")]
        pub timestamp_field: ::core::option::Option<super::FieldId>,
        /// When the job is started by a JobTrigger we will automatically figure out
        /// a valid start_time to avoid scanning files that have not been modified
        /// since the last time the JobTrigger executed. This will be based on the
        /// time of the execution of the last run of the JobTrigger.
        #[prost(bool, tag = "4")]
        pub enable_auto_population_of_timespan_config: bool,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Google Cloud Datastore options.
        #[prost(message, tag = "2")]
        DatastoreOptions(super::DatastoreOptions),
        /// Google Cloud Storage options.
        #[prost(message, tag = "3")]
        CloudStorageOptions(super::CloudStorageOptions),
        /// BigQuery options.
        #[prost(message, tag = "4")]
        BigQueryOptions(super::BigQueryOptions),
        /// Hybrid inspection options.
        /// Early access feature is in a pre-release state and might change or have
        /// limited support. For more information, see
        /// <https://cloud.google.com/products#product-launch-stages.>
        #[prost(message, tag = "9")]
        HybridOptions(super::HybridOptions),
    }
}
/// Configuration to control jobs where the content being inspected is outside
/// of Google Cloud Platform.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridOptions {
    /// A short description of where the data is coming from. Will be stored once
    /// in the job. 256 max length.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// These are labels that each inspection request must include within their
    /// 'finding_labels' map. Request may contain others, but any missing one of
    /// these will be rejected.
    ///
    /// Label keys must be between 1 and 63 characters long and must conform
    /// to the following regular expression: `\[a-z]([-a-z0-9]*[a-z0-9\])?`.
    ///
    /// No more than 10 keys can be required.
    #[prost(string, repeated, tag = "2")]
    pub required_finding_label_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// To organize findings, these labels will be added to each finding.
    ///
    /// Label keys must be between 1 and 63 characters long and must conform
    /// to the following regular expression: `\[a-z]([-a-z0-9]*[a-z0-9\])?`.
    ///
    /// Label values must be between 0 and 63 characters long and must conform
    /// to the regular expression `(\[a-z]([-a-z0-9]*[a-z0-9\])?)?`.
    ///
    /// No more than 10 labels can be associated with a given finding.
    ///
    /// Examples:
    /// * `"environment" : "production"`
    /// * `"pipeline" : "etl"`
    #[prost(map = "string, string", tag = "3")]
    pub labels:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// If the container is a table, additional information to make findings
    /// meaningful such as the columns that are primary keys.
    #[prost(message, optional, tag = "4")]
    pub table_options: ::core::option::Option<TableOptions>,
}
/// Row key for identifying a record in BigQuery table.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigQueryKey {
    /// Complete BigQuery table reference.
    #[prost(message, optional, tag = "1")]
    pub table_reference: ::core::option::Option<BigQueryTable>,
    /// Row number inferred at the time the table was scanned. This value is
    /// nondeterministic, cannot be queried, and may be null for inspection
    /// jobs. To locate findings within a table, specify
    /// `inspect_job.storage_config.big_query_options.identifying_fields` in
    /// `CreateDlpJobRequest`.
    #[prost(int64, tag = "2")]
    pub row_number: i64,
}
/// Record key for a finding in Cloud Datastore.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatastoreKey {
    /// Datastore entity key.
    #[prost(message, optional, tag = "1")]
    pub entity_key: ::core::option::Option<Key>,
}
/// A unique identifier for a Datastore entity.
/// If a key's partition ID or any of its path kinds or names are
/// reserved/read-only, the key is reserved/read-only.
/// A reserved/read-only key is forbidden in certain documented contexts.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Key {
    /// Entities are partitioned into subsets, currently identified by a project
    /// ID and namespace ID.
    /// Queries are scoped to a single partition.
    #[prost(message, optional, tag = "1")]
    pub partition_id: ::core::option::Option<PartitionId>,
    /// The entity path.
    /// An entity path consists of one or more elements composed of a kind and a
    /// string or numerical identifier, which identify entities. The first
    /// element identifies a _root entity_, the second element identifies
    /// a _child_ of the root entity, the third element identifies a child of the
    /// second entity, and so forth. The entities identified by all prefixes of
    /// the path are called the element's _ancestors_.
    ///
    /// A path can never be empty, and a path can have at most 100 elements.
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<key::PathElement>,
}
/// Nested message and enum types in `Key`.
pub mod key {
    /// A (kind, ID/name) pair used to construct a key path.
    ///
    /// If either name or ID is set, the element is complete.
    /// If neither is set, the element is incomplete.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PathElement {
        /// The kind of the entity.
        /// A kind matching regex `__.*__` is reserved/read-only.
        /// A kind must not contain more than 1500 bytes when UTF-8 encoded.
        /// Cannot be `""`.
        #[prost(string, tag = "1")]
        pub kind: ::prost::alloc::string::String,
        /// The type of ID.
        #[prost(oneof = "path_element::IdType", tags = "2, 3")]
        pub id_type: ::core::option::Option<path_element::IdType>,
    }
    /// Nested message and enum types in `PathElement`.
    pub mod path_element {
        /// The type of ID.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum IdType {
            /// The auto-allocated ID of the entity.
            /// Never equal to zero. Values less than zero are discouraged and may not
            /// be supported in the future.
            #[prost(int64, tag = "2")]
            Id(i64),
            /// The name of the entity.
            /// A name matching regex `__.*__` is reserved/read-only.
            /// A name must not be more than 1500 bytes when UTF-8 encoded.
            /// Cannot be `""`.
            #[prost(string, tag = "3")]
            Name(::prost::alloc::string::String),
        }
    }
}
/// Message for a unique key indicating a record that contains a finding.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordKey {
    /// Values of identifying columns in the given row. Order of values matches
    /// the order of `identifying_fields` specified in the scanning request.
    #[prost(string, repeated, tag = "5")]
    pub id_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(oneof = "record_key::Type", tags = "2, 3")]
    pub r#type: ::core::option::Option<record_key::Type>,
}
/// Nested message and enum types in `RecordKey`.
pub mod record_key {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "2")]
        DatastoreKey(super::DatastoreKey),
        #[prost(message, tag = "3")]
        BigQueryKey(super::BigQueryKey),
    }
}
/// Message defining the location of a BigQuery table. A table is uniquely
/// identified  by its project_id, dataset_id, and table_name. Within a query
/// a table is often referenced with a string in the format of:
/// `<project_id>:<dataset_id>.<table_id>` or
/// `<project_id>.<dataset_id>.<table_id>`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigQueryTable {
    /// The Google Cloud Platform project ID of the project containing the table.
    /// If omitted, project ID is inferred from the API call.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Dataset ID of the table.
    #[prost(string, tag = "2")]
    pub dataset_id: ::prost::alloc::string::String,
    /// Name of the table.
    #[prost(string, tag = "3")]
    pub table_id: ::prost::alloc::string::String,
}
/// Message defining a field of a BigQuery table.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigQueryField {
    /// Source table of the field.
    #[prost(message, optional, tag = "1")]
    pub table: ::core::option::Option<BigQueryTable>,
    /// Designated field in the BigQuery table.
    #[prost(message, optional, tag = "2")]
    pub field: ::core::option::Option<FieldId>,
}
/// An entity in a dataset is a field or set of fields that correspond to a
/// single person. For example, in medical records the `EntityId` might be a
/// patient identifier, or for financial records it might be an account
/// identifier. This message is used when generalizations or analysis must take
/// into account that multiple rows correspond to the same entity.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityId {
    /// Composite key indicating which field contains the entity identifier.
    #[prost(message, optional, tag = "1")]
    pub field: ::core::option::Option<FieldId>,
}
/// Instructions regarding the table content being inspected.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TableOptions {
    /// The columns that are the primary keys for table objects included in
    /// ContentItem. A copy of this cell's value will stored alongside alongside
    /// each finding so that the finding can be traced to the specific row it came
    /// from. No more than 3 may be provided.
    #[prost(message, repeated, tag = "1")]
    pub identifying_fields: ::prost::alloc::vec::Vec<FieldId>,
}
/// Categorization of results based on how likely they are to represent a match,
/// based on the number of elements they contain which imply a match.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Likelihood {
    /// Default value; same as POSSIBLE.
    Unspecified = 0,
    /// Few matching elements.
    VeryUnlikely = 1,
    Unlikely = 2,
    /// Some matching elements.
    Possible = 3,
    Likely = 4,
    /// Many matching elements.
    VeryLikely = 5,
}
/// Definitions of file type groups to scan. New types will be added to this
/// list.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FileType {
    /// Includes all files.
    Unspecified = 0,
    /// Includes all file extensions not covered by another entry. Binary
    /// scanning attempts to convert the content of the file to utf_8 to scan
    /// the file.
    /// If you wish to avoid this fall back, specify one or more of the other
    /// FileType's in your storage scan.
    BinaryFile = 1,
    /// Included file extensions:
    ///   asc, brf, c, cc, cpp, csv, cxx, c++, cs, css, dart, eml, go, h, hh, hpp,
    ///   hxx, h++, hs, html, htm, shtml, shtm, xhtml, lhs, ini, java, js, json,
    ///   ocaml, md, mkd, markdown, m, ml, mli, pl, pm, php, phtml, pht, py, pyw,
    ///   rb, rbw, rs, rc, scala, sh, sql, tex, txt, text, tsv, vcard, vcs, wml,
    ///   xml, xsl, xsd, yml, yaml.
    TextFile = 2,
    /// Included file extensions:
    ///   bmp, gif, jpg, jpeg, jpe, png.
    /// bytes_limit_per_file has no effect on image files.
    /// Image inspection is restricted to 'global', 'us', 'asia', and 'europe'.
    Image = 3,
    /// Word files >30 MB will be scanned as binary files.
    /// Included file extensions:
    ///   docx, dotx, docm, dotm
    Word = 5,
    /// PDF files >30 MB will be scanned as binary files.
    /// Included file extensions:
    ///   pdf
    Pdf = 6,
    /// Included file extensions:
    ///   avro
    Avro = 7,
    /// Included file extensions:
    ///   csv
    Csv = 8,
    /// Included file extensions:
    ///   tsv
    Tsv = 9,
}
/// List of exclude infoTypes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExcludeInfoTypes {
    /// InfoType list in ExclusionRule rule drops a finding when it overlaps or
    /// contained within with a finding of an infoType from this list. For
    /// example, for `InspectionRuleSet.info_types` containing "PHONE_NUMBER"` and
    /// `exclusion_rule` containing `exclude_info_types.info_types` with
    /// "EMAIL_ADDRESS" the phone number findings are dropped if they overlap
    /// with EMAIL_ADDRESS finding.
    /// That leads to "555-222-2222@example.org" to generate only a single
    /// finding, namely email address.
    #[prost(message, repeated, tag = "1")]
    pub info_types: ::prost::alloc::vec::Vec<InfoType>,
}
/// The rule that specifies conditions when findings of infoTypes specified in
/// `InspectionRuleSet` are removed from results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExclusionRule {
    /// How the rule is applied, see MatchingType documentation for details.
    #[prost(enumeration = "MatchingType", tag = "4")]
    pub matching_type: i32,
    /// Exclusion rule types.
    #[prost(oneof = "exclusion_rule::Type", tags = "1, 2, 3")]
    pub r#type: ::core::option::Option<exclusion_rule::Type>,
}
/// Nested message and enum types in `ExclusionRule`.
pub mod exclusion_rule {
    /// Exclusion rule types.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Dictionary which defines the rule.
        #[prost(message, tag = "1")]
        Dictionary(super::custom_info_type::Dictionary),
        /// Regular expression which defines the rule.
        #[prost(message, tag = "2")]
        Regex(super::custom_info_type::Regex),
        /// Set of infoTypes for which findings would affect this rule.
        #[prost(message, tag = "3")]
        ExcludeInfoTypes(super::ExcludeInfoTypes),
    }
}
/// A single inspection rule to be applied to infoTypes, specified in
/// `InspectionRuleSet`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectionRule {
    /// Inspection rule types.
    #[prost(oneof = "inspection_rule::Type", tags = "1, 2")]
    pub r#type: ::core::option::Option<inspection_rule::Type>,
}
/// Nested message and enum types in `InspectionRule`.
pub mod inspection_rule {
    /// Inspection rule types.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Hotword-based detection rule.
        #[prost(message, tag = "1")]
        HotwordRule(super::custom_info_type::detection_rule::HotwordRule),
        /// Exclusion rule.
        #[prost(message, tag = "2")]
        ExclusionRule(super::ExclusionRule),
    }
}
/// Rule set for modifying a set of infoTypes to alter behavior under certain
/// circumstances, depending on the specific details of the rules within the set.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectionRuleSet {
    /// List of infoTypes this rule set is applied to.
    #[prost(message, repeated, tag = "1")]
    pub info_types: ::prost::alloc::vec::Vec<InfoType>,
    /// Set of rules to be applied to infoTypes. The rules are applied in order.
    #[prost(message, repeated, tag = "2")]
    pub rules: ::prost::alloc::vec::Vec<InspectionRule>,
}
/// Configuration description of the scanning process.
/// When used with redactContent only info_types and min_likelihood are currently
/// used.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectConfig {
    /// Restricts what info_types to look for. The values must correspond to
    /// InfoType values returned by ListInfoTypes or listed at
    /// <https://cloud.google.com/dlp/docs/infotypes-reference.>
    ///
    /// When no InfoTypes or CustomInfoTypes are specified in a request, the
    /// system may automatically choose what detectors to run. By default this may
    /// be all types, but may change over time as detectors are updated.
    ///
    /// If you need precise control and predictability as to what detectors are
    /// run you should specify specific InfoTypes listed in the reference,
    /// otherwise a default list will be used, which may change over time.
    #[prost(message, repeated, tag = "1")]
    pub info_types: ::prost::alloc::vec::Vec<InfoType>,
    /// Only returns findings equal or above this threshold. The default is
    /// POSSIBLE.
    /// See <https://cloud.google.com/dlp/docs/likelihood> to learn more.
    #[prost(enumeration = "Likelihood", tag = "2")]
    pub min_likelihood: i32,
    /// Configuration to control the number of findings returned.
    #[prost(message, optional, tag = "3")]
    pub limits: ::core::option::Option<inspect_config::FindingLimits>,
    /// When true, a contextual quote from the data that triggered a finding is
    /// included in the response; see Finding.quote.
    #[prost(bool, tag = "4")]
    pub include_quote: bool,
    /// When true, excludes type information of the findings.
    #[prost(bool, tag = "5")]
    pub exclude_info_types: bool,
    /// CustomInfoTypes provided by the user. See
    /// <https://cloud.google.com/dlp/docs/creating-custom-infotypes> to learn more.
    #[prost(message, repeated, tag = "6")]
    pub custom_info_types: ::prost::alloc::vec::Vec<CustomInfoType>,
    /// List of options defining data content to scan.
    /// If empty, text, images, and other content will be included.
    #[prost(enumeration = "ContentOption", repeated, tag = "8")]
    pub content_options: ::prost::alloc::vec::Vec<i32>,
    /// Set of rules to apply to the findings for this InspectConfig.
    /// Exclusion rules, contained in the set are executed in the end, other
    /// rules are executed in the order they are specified for each info type.
    #[prost(message, repeated, tag = "10")]
    pub rule_set: ::prost::alloc::vec::Vec<InspectionRuleSet>,
}
/// Nested message and enum types in `InspectConfig`.
pub mod inspect_config {
    /// Configuration to control the number of findings returned.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FindingLimits {
        /// Max number of findings that will be returned for each item scanned.
        /// When set within `InspectJobConfig`,
        /// the maximum returned is 2000 regardless if this is set higher.
        /// When set within `InspectContentRequest`, this field is ignored.
        #[prost(int32, tag = "1")]
        pub max_findings_per_item: i32,
        /// Max number of findings that will be returned per request/job.
        /// When set within `InspectContentRequest`, the maximum returned is 2000
        /// regardless if this is set higher.
        #[prost(int32, tag = "2")]
        pub max_findings_per_request: i32,
        /// Configuration of findings limit given for specified infoTypes.
        #[prost(message, repeated, tag = "3")]
        pub max_findings_per_info_type: ::prost::alloc::vec::Vec<finding_limits::InfoTypeLimit>,
    }
    /// Nested message and enum types in `FindingLimits`.
    pub mod finding_limits {
        /// Max findings configuration per infoType, per content item or long
        /// running DlpJob.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct InfoTypeLimit {
            /// Type of information the findings limit applies to. Only one limit per
            /// info_type should be provided. If InfoTypeLimit does not have an
            /// info_type, the DLP API applies the limit against all info_types that
            /// are found but not specified in another InfoTypeLimit.
            #[prost(message, optional, tag = "1")]
            pub info_type: ::core::option::Option<super::super::InfoType>,
            /// Max findings limit for the given infoType.
            #[prost(int32, tag = "2")]
            pub max_findings: i32,
        }
    }
}
/// Container for bytes to inspect or redact.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ByteContentItem {
    /// The type of data stored in the bytes string. Default will be TEXT_UTF8.
    #[prost(enumeration = "byte_content_item::BytesType", tag = "1")]
    pub r#type: i32,
    /// Content data to inspect or redact.
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Nested message and enum types in `ByteContentItem`.
pub mod byte_content_item {
    /// The type of data being sent for inspection.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum BytesType {
        /// Unused
        Unspecified = 0,
        /// Any image type.
        Image = 6,
        /// jpeg
        ImageJpeg = 1,
        /// bmp
        ImageBmp = 2,
        /// png
        ImagePng = 3,
        /// svg
        ImageSvg = 4,
        /// plain text
        TextUtf8 = 5,
        /// docx, docm, dotx, dotm
        WordDocument = 7,
        /// pdf
        Pdf = 8,
        /// avro
        Avro = 11,
        /// csv
        Csv = 12,
        /// tsv
        Tsv = 13,
    }
}
/// Container structure for the content to inspect.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContentItem {
    /// Data of the item either in the byte array or UTF-8 string form, or table.
    #[prost(oneof = "content_item::DataItem", tags = "3, 4, 5")]
    pub data_item: ::core::option::Option<content_item::DataItem>,
}
/// Nested message and enum types in `ContentItem`.
pub mod content_item {
    /// Data of the item either in the byte array or UTF-8 string form, or table.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DataItem {
        /// String data to inspect or redact.
        #[prost(string, tag = "3")]
        Value(::prost::alloc::string::String),
        /// Structured content for inspection. See
        /// <https://cloud.google.com/dlp/docs/inspecting-text#inspecting_a_table> to
        /// learn more.
        #[prost(message, tag = "4")]
        Table(super::Table),
        /// Content data to inspect or redact. Replaces `type` and `data`.
        #[prost(message, tag = "5")]
        ByteItem(super::ByteContentItem),
    }
}
/// Structured content to inspect. Up to 50,000 `Value`s per request allowed.
/// See <https://cloud.google.com/dlp/docs/inspecting-text#inspecting_a_table> to
/// learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Table {
    /// Headers of the table.
    #[prost(message, repeated, tag = "1")]
    pub headers: ::prost::alloc::vec::Vec<FieldId>,
    /// Rows of the table.
    #[prost(message, repeated, tag = "2")]
    pub rows: ::prost::alloc::vec::Vec<table::Row>,
}
/// Nested message and enum types in `Table`.
pub mod table {
    /// Values of the row.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Row {
        /// Individual cells.
        #[prost(message, repeated, tag = "1")]
        pub values: ::prost::alloc::vec::Vec<super::Value>,
    }
}
/// All the findings for a single scanned item.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectResult {
    /// List of findings for an item.
    #[prost(message, repeated, tag = "1")]
    pub findings: ::prost::alloc::vec::Vec<Finding>,
    /// If true, then this item might have more findings than were returned,
    /// and the findings returned are an arbitrary subset of all findings.
    /// The findings list might be truncated because the input items were too
    /// large, or because the server reached the maximum amount of resources
    /// allowed for a single API call. For best results, divide the input into
    /// smaller batches.
    #[prost(bool, tag = "2")]
    pub findings_truncated: bool,
}
/// Represents a piece of potentially sensitive content.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Finding {
    /// Resource name in format
    /// projects/{project}/locations/{location}/findings/{finding} Populated only
    /// when viewing persisted findings.
    #[prost(string, tag = "14")]
    pub name: ::prost::alloc::string::String,
    /// The content that was found. Even if the content is not textual, it
    /// may be converted to a textual representation here.
    /// Provided if `include_quote` is true and the finding is
    /// less than or equal to 4096 bytes long. If the finding exceeds 4096 bytes
    /// in length, the quote may be omitted.
    #[prost(string, tag = "1")]
    pub quote: ::prost::alloc::string::String,
    /// The type of content that might have been found.
    /// Provided if `excluded_types` is false.
    #[prost(message, optional, tag = "2")]
    pub info_type: ::core::option::Option<InfoType>,
    /// Confidence of how likely it is that the `info_type` is correct.
    #[prost(enumeration = "Likelihood", tag = "3")]
    pub likelihood: i32,
    /// Where the content was found.
    #[prost(message, optional, tag = "4")]
    pub location: ::core::option::Option<Location>,
    /// Timestamp when finding was detected.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Contains data parsed from quotes. Only populated if include_quote was set
    /// to true and a supported infoType was requested. Currently supported
    /// infoTypes: DATE, DATE_OF_BIRTH and TIME.
    #[prost(message, optional, tag = "7")]
    pub quote_info: ::core::option::Option<QuoteInfo>,
    /// The job that stored the finding.
    #[prost(string, tag = "8")]
    pub resource_name: ::prost::alloc::string::String,
    /// Job trigger name, if applicable, for this finding.
    #[prost(string, tag = "9")]
    pub trigger_name: ::prost::alloc::string::String,
    /// The labels associated with this `Finding`.
    ///
    /// Label keys must be between 1 and 63 characters long and must conform
    /// to the following regular expression: `\[a-z]([-a-z0-9]*[a-z0-9\])?`.
    ///
    /// Label values must be between 0 and 63 characters long and must conform
    /// to the regular expression `(\[a-z]([-a-z0-9]*[a-z0-9\])?)?`.
    ///
    /// No more than 10 labels can be associated with a given finding.
    ///
    /// Examples:
    /// * `"environment" : "production"`
    /// * `"pipeline" : "etl"`
    #[prost(map = "string, string", tag = "10")]
    pub labels:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Time the job started that produced this finding.
    #[prost(message, optional, tag = "11")]
    pub job_create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The job that stored the finding.
    #[prost(string, tag = "13")]
    pub job_name: ::prost::alloc::string::String,
}
/// Specifies the location of the finding.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Location {
    /// Zero-based byte offsets delimiting the finding.
    /// These are relative to the finding's containing element.
    /// Note that when the content is not textual, this references
    /// the UTF-8 encoded textual representation of the content.
    /// Omitted if content is an image.
    #[prost(message, optional, tag = "1")]
    pub byte_range: ::core::option::Option<Range>,
    /// Unicode character offsets delimiting the finding.
    /// These are relative to the finding's containing element.
    /// Provided when the content is text.
    #[prost(message, optional, tag = "2")]
    pub codepoint_range: ::core::option::Option<Range>,
    /// List of nested objects pointing to the precise location of the finding
    /// within the file or record.
    #[prost(message, repeated, tag = "7")]
    pub content_locations: ::prost::alloc::vec::Vec<ContentLocation>,
    /// Information about the container where this finding occurred, if available.
    #[prost(message, optional, tag = "8")]
    pub container: ::core::option::Option<Container>,
}
/// Precise location of the finding within a document, record, image, or metadata
/// container.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContentLocation {
    /// Name of the container where the finding is located.
    /// The top level name is the source file name or table name. Names of some
    /// common storage containers are formatted as follows:
    ///
    /// * BigQuery tables:  `{project_id}:{dataset_id}.{table_id}`
    /// * Cloud Storage files: `gs://{bucket}/{path}`
    /// * Datastore namespace: {namespace}
    ///
    /// Nested names could be absent if the embedded object has no string
    /// identifier (for an example an image contained within a document).
    #[prost(string, tag = "1")]
    pub container_name: ::prost::alloc::string::String,
    /// Findings container modification timestamp, if applicable.
    /// For Google Cloud Storage contains last file modification timestamp.
    /// For BigQuery table contains last_modified_time property.
    /// For Datastore - not populated.
    #[prost(message, optional, tag = "6")]
    pub container_timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// Findings container version, if available
    /// ("generation" for Google Cloud Storage).
    #[prost(string, tag = "7")]
    pub container_version: ::prost::alloc::string::String,
    /// Type of the container within the file with location of the finding.
    #[prost(oneof = "content_location::Location", tags = "2, 3, 5, 8")]
    pub location: ::core::option::Option<content_location::Location>,
}
/// Nested message and enum types in `ContentLocation`.
pub mod content_location {
    /// Type of the container within the file with location of the finding.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Location {
        /// Location within a row or record of a database table.
        #[prost(message, tag = "2")]
        RecordLocation(super::RecordLocation),
        /// Location within an image's pixels.
        #[prost(message, tag = "3")]
        ImageLocation(super::ImageLocation),
        /// Location data for document files.
        #[prost(message, tag = "5")]
        DocumentLocation(super::DocumentLocation),
        /// Location within the metadata for inspected content.
        #[prost(message, tag = "8")]
        MetadataLocation(super::MetadataLocation),
    }
}
/// Metadata Location
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetadataLocation {
    /// Type of metadata containing the finding.
    #[prost(enumeration = "MetadataType", tag = "1")]
    pub r#type: i32,
    /// Label of the piece of metadata containing the finding, for example -
    /// latitude, author, caption.
    #[prost(oneof = "metadata_location::Label", tags = "3")]
    pub label: ::core::option::Option<metadata_location::Label>,
}
/// Nested message and enum types in `MetadataLocation`.
pub mod metadata_location {
    /// Label of the piece of metadata containing the finding, for example -
    /// latitude, author, caption.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Label {
        /// Storage metadata.
        #[prost(message, tag = "3")]
        StorageLabel(super::StorageMetadataLabel),
    }
}
/// Storage metadata label to indicate which metadata entry contains findings.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageMetadataLabel {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
}
/// Location of a finding within a document.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DocumentLocation {
    /// Offset of the line, from the beginning of the file, where the finding
    /// is located.
    #[prost(int64, tag = "1")]
    pub file_offset: i64,
}
/// Location of a finding within a row or record.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordLocation {
    /// Key of the finding.
    #[prost(message, optional, tag = "1")]
    pub record_key: ::core::option::Option<RecordKey>,
    /// Field id of the field containing the finding.
    #[prost(message, optional, tag = "2")]
    pub field_id: ::core::option::Option<FieldId>,
    /// Location within a `ContentItem.Table`.
    #[prost(message, optional, tag = "3")]
    pub table_location: ::core::option::Option<TableLocation>,
}
/// Location of a finding within a table.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TableLocation {
    /// The zero-based index of the row where the finding is located. Only
    /// populated for resources that have a natural ordering, not BigQuery. In
    /// BigQuery, to identify the row a finding came from, populate
    /// BigQueryOptions.identifying_fields with your primary key column names and
    /// when you store the findings the value of those columns will be stored
    /// inside of Finding.
    #[prost(int64, tag = "1")]
    pub row_index: i64,
}
/// Represents a container that may contain DLP findings.
/// Examples of a container include a file, table, or database record.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Container {
    /// Container type, for example BigQuery or Google Cloud Storage.
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Project where the finding was found.
    /// Can be different from the project that owns the finding.
    #[prost(string, tag = "2")]
    pub project_id: ::prost::alloc::string::String,
    /// A string representation of the full container name.
    /// Examples:
    /// - BigQuery: 'Project:DataSetId.TableId'
    /// - Google Cloud Storage: 'gs://Bucket/folders/filename.txt'
    #[prost(string, tag = "3")]
    pub full_path: ::prost::alloc::string::String,
    /// The root of the container.
    /// Examples:
    /// - For BigQuery table `project_id:dataset_id.table_id`, the root is
    ///  `dataset_id`
    /// - For Google Cloud Storage file `gs://bucket/folder/filename.txt`, the root
    ///  is `gs://bucket`
    #[prost(string, tag = "4")]
    pub root_path: ::prost::alloc::string::String,
    /// The rest of the path after the root.
    /// Examples:
    /// - For BigQuery table `project_id:dataset_id.table_id`, the relative path is
    ///  `table_id`
    /// - Google Cloud Storage file `gs://bucket/folder/filename.txt`, the relative
    ///  path is `folder/filename.txt`
    #[prost(string, tag = "5")]
    pub relative_path: ::prost::alloc::string::String,
    /// Findings container modification timestamp, if applicable.
    /// For Google Cloud Storage contains last file modification timestamp.
    /// For BigQuery table contains last_modified_time property.
    /// For Datastore - not populated.
    #[prost(message, optional, tag = "6")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Findings container version, if available
    /// ("generation" for Google Cloud Storage).
    #[prost(string, tag = "7")]
    pub version: ::prost::alloc::string::String,
}
/// Generic half-open interval [start, end)
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Range {
    /// Index of the first character of the range (inclusive).
    #[prost(int64, tag = "1")]
    pub start: i64,
    /// Index of the last character of the range (exclusive).
    #[prost(int64, tag = "2")]
    pub end: i64,
}
/// Location of the finding within an image.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImageLocation {
    /// Bounding boxes locating the pixels within the image containing the finding.
    #[prost(message, repeated, tag = "1")]
    pub bounding_boxes: ::prost::alloc::vec::Vec<BoundingBox>,
}
/// Bounding box encompassing detected text within an image.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoundingBox {
    /// Top coordinate of the bounding box. (0,0) is upper left.
    #[prost(int32, tag = "1")]
    pub top: i32,
    /// Left coordinate of the bounding box. (0,0) is upper left.
    #[prost(int32, tag = "2")]
    pub left: i32,
    /// Width of the bounding box in pixels.
    #[prost(int32, tag = "3")]
    pub width: i32,
    /// Height of the bounding box in pixels.
    #[prost(int32, tag = "4")]
    pub height: i32,
}
/// Request to search for potentially sensitive info in an image and redact it
/// by covering it with a colored rectangle.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedactImageRequest {
    /// Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "8")]
    pub location_id: ::prost::alloc::string::String,
    /// Configuration for the inspector.
    #[prost(message, optional, tag = "2")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
    /// The configuration for specifying what content to redact from images.
    #[prost(message, repeated, tag = "5")]
    pub image_redaction_configs:
        ::prost::alloc::vec::Vec<redact_image_request::ImageRedactionConfig>,
    /// Whether the response should include findings along with the redacted
    /// image.
    #[prost(bool, tag = "6")]
    pub include_findings: bool,
    /// The content must be PNG, JPEG, SVG or BMP.
    #[prost(message, optional, tag = "7")]
    pub byte_item: ::core::option::Option<ByteContentItem>,
}
/// Nested message and enum types in `RedactImageRequest`.
pub mod redact_image_request {
    /// Configuration for determining how redaction of images should occur.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ImageRedactionConfig {
        /// The color to use when redacting content from an image. If not specified,
        /// the default is black.
        #[prost(message, optional, tag = "3")]
        pub redaction_color: ::core::option::Option<super::Color>,
        /// Type of information to redact from images.
        #[prost(oneof = "image_redaction_config::Target", tags = "1, 2")]
        pub target: ::core::option::Option<image_redaction_config::Target>,
    }
    /// Nested message and enum types in `ImageRedactionConfig`.
    pub mod image_redaction_config {
        /// Type of information to redact from images.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Target {
            /// Only one per info_type should be provided per request. If not
            /// specified, and redact_all_text is false, the DLP API will redact all
            /// text that it matches against all info_types that are found, but not
            /// specified in another ImageRedactionConfig.
            #[prost(message, tag = "1")]
            InfoType(super::super::InfoType),
            /// If true, all text found in the image, regardless whether it matches an
            /// info_type, is redacted. Only one should be provided.
            #[prost(bool, tag = "2")]
            RedactAllText(bool),
        }
    }
}
/// Represents a color in the RGB color space.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Color {
    /// The amount of red in the color as a value in the interval [0, 1].
    #[prost(float, tag = "1")]
    pub red: f32,
    /// The amount of green in the color as a value in the interval [0, 1].
    #[prost(float, tag = "2")]
    pub green: f32,
    /// The amount of blue in the color as a value in the interval [0, 1].
    #[prost(float, tag = "3")]
    pub blue: f32,
}
/// Results of redacting an image.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedactImageResponse {
    /// The redacted image. The type will be the same as the original image.
    #[prost(bytes = "vec", tag = "1")]
    pub redacted_image: ::prost::alloc::vec::Vec<u8>,
    /// If an image was being inspected and the InspectConfig's include_quote was
    /// set to true, then this field will include all text, if any, that was found
    /// in the image.
    #[prost(string, tag = "2")]
    pub extracted_text: ::prost::alloc::string::String,
    /// The findings. Populated when include_findings in the request is true.
    #[prost(message, optional, tag = "3")]
    pub inspect_result: ::core::option::Option<InspectResult>,
}
/// Request to de-identify a list of items.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeidentifyContentRequest {
    /// Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Configuration for the de-identification of the content item.
    /// Items specified here will override the template referenced by the
    /// deidentify_template_name argument.
    #[prost(message, optional, tag = "2")]
    pub deidentify_config: ::core::option::Option<DeidentifyConfig>,
    /// Configuration for the inspector.
    /// Items specified here will override the template referenced by the
    /// inspect_template_name argument.
    #[prost(message, optional, tag = "3")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
    /// The item to de-identify. Will be treated as text.
    #[prost(message, optional, tag = "4")]
    pub item: ::core::option::Option<ContentItem>,
    /// Template to use. Any configuration directly specified in
    /// inspect_config will override those set in the template. Singular fields
    /// that are set in this request will replace their corresponding fields in the
    /// template. Repeated fields are appended. Singular sub-messages and groups
    /// are recursively merged.
    #[prost(string, tag = "5")]
    pub inspect_template_name: ::prost::alloc::string::String,
    /// Template to use. Any configuration directly specified in
    /// deidentify_config will override those set in the template. Singular fields
    /// that are set in this request will replace their corresponding fields in the
    /// template. Repeated fields are appended. Singular sub-messages and groups
    /// are recursively merged.
    #[prost(string, tag = "6")]
    pub deidentify_template_name: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "7")]
    pub location_id: ::prost::alloc::string::String,
}
/// Results of de-identifying a ContentItem.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeidentifyContentResponse {
    /// The de-identified item.
    #[prost(message, optional, tag = "1")]
    pub item: ::core::option::Option<ContentItem>,
    /// An overview of the changes that were made on the `item`.
    #[prost(message, optional, tag = "2")]
    pub overview: ::core::option::Option<TransformationOverview>,
}
/// Request to re-identify an item.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReidentifyContentRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Configuration for the re-identification of the content item.
    /// This field shares the same proto message type that is used for
    /// de-identification, however its usage here is for the reversal of the
    /// previous de-identification. Re-identification is performed by examining
    /// the transformations used to de-identify the items and executing the
    /// reverse. This requires that only reversible transformations
    /// be provided here. The reversible transformations are:
    ///
    ///  - `CryptoDeterministicConfig`
    ///  - `CryptoReplaceFfxFpeConfig`
    #[prost(message, optional, tag = "2")]
    pub reidentify_config: ::core::option::Option<DeidentifyConfig>,
    /// Configuration for the inspector.
    #[prost(message, optional, tag = "3")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
    /// The item to re-identify. Will be treated as text.
    #[prost(message, optional, tag = "4")]
    pub item: ::core::option::Option<ContentItem>,
    /// Template to use. Any configuration directly specified in
    /// `inspect_config` will override those set in the template. Singular fields
    /// that are set in this request will replace their corresponding fields in the
    /// template. Repeated fields are appended. Singular sub-messages and groups
    /// are recursively merged.
    #[prost(string, tag = "5")]
    pub inspect_template_name: ::prost::alloc::string::String,
    /// Template to use. References an instance of `DeidentifyTemplate`.
    /// Any configuration directly specified in `reidentify_config` or
    /// `inspect_config` will override those set in the template. The
    /// `DeidentifyTemplate` used must include only reversible transformations.
    /// Singular fields that are set in this request will replace their
    /// corresponding fields in the template. Repeated fields are appended.
    /// Singular sub-messages and groups are recursively merged.
    #[prost(string, tag = "6")]
    pub reidentify_template_name: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "7")]
    pub location_id: ::prost::alloc::string::String,
}
/// Results of re-identifying a item.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReidentifyContentResponse {
    /// The re-identified item.
    #[prost(message, optional, tag = "1")]
    pub item: ::core::option::Option<ContentItem>,
    /// An overview of the changes that were made to the `item`.
    #[prost(message, optional, tag = "2")]
    pub overview: ::core::option::Option<TransformationOverview>,
}
/// Request to search for potentially sensitive info in a ContentItem.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectContentRequest {
    /// Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Configuration for the inspector. What specified here will override
    /// the template referenced by the inspect_template_name argument.
    #[prost(message, optional, tag = "2")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
    /// The item to inspect.
    #[prost(message, optional, tag = "3")]
    pub item: ::core::option::Option<ContentItem>,
    /// Template to use. Any configuration directly specified in
    /// inspect_config will override those set in the template. Singular fields
    /// that are set in this request will replace their corresponding fields in the
    /// template. Repeated fields are appended. Singular sub-messages and groups
    /// are recursively merged.
    #[prost(string, tag = "4")]
    pub inspect_template_name: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "5")]
    pub location_id: ::prost::alloc::string::String,
}
/// Results of inspecting an item.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectContentResponse {
    /// The findings.
    #[prost(message, optional, tag = "1")]
    pub result: ::core::option::Option<InspectResult>,
}
/// Cloud repository for storing output.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutputStorageConfig {
    /// Schema used for writing the findings for Inspect jobs. This field is only
    /// used for Inspect and must be unspecified for Risk jobs. Columns are derived
    /// from the `Finding` object. If appending to an existing table, any columns
    /// from the predefined schema that are missing will be added. No columns in
    /// the existing table will be deleted.
    ///
    /// If unspecified, then all available columns will be used for a new table or
    /// an (existing) table with no schema, and no changes will be made to an
    /// existing table that has a schema.
    /// Only for use with external storage.
    #[prost(enumeration = "output_storage_config::OutputSchema", tag = "3")]
    pub output_schema: i32,
    /// Output storage types.
    #[prost(oneof = "output_storage_config::Type", tags = "1")]
    pub r#type: ::core::option::Option<output_storage_config::Type>,
}
/// Nested message and enum types in `OutputStorageConfig`.
pub mod output_storage_config {
    /// Predefined schemas for storing findings.
    /// Only for use with external storage.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum OutputSchema {
        /// Unused.
        Unspecified = 0,
        /// Basic schema including only `info_type`, `quote`, `certainty`, and
        /// `timestamp`.
        BasicColumns = 1,
        /// Schema tailored to findings from scanning Google Cloud Storage.
        GcsColumns = 2,
        /// Schema tailored to findings from scanning Google Datastore.
        DatastoreColumns = 3,
        /// Schema tailored to findings from scanning Google BigQuery.
        BigQueryColumns = 4,
        /// Schema containing all columns.
        AllColumns = 5,
    }
    /// Output storage types.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Store findings in an existing table or a new table in an existing
        /// dataset. If table_id is not set a new one will be generated
        /// for you with the following format:
        /// dlp_googleapis_yyyy_mm_dd_\[dlp_job_id\]. Pacific timezone will be used for
        /// generating the date details.
        ///
        /// For Inspect, each column in an existing output table must have the same
        /// name, type, and mode of a field in the `Finding` object.
        ///
        /// For Risk, an existing output table should be the output of a previous
        /// Risk analysis job run on the same source table, with the same privacy
        /// metric and quasi-identifiers. Risk jobs that analyze the same table but
        /// compute a different privacy metric, or use different sets of
        /// quasi-identifiers, cannot store their results in the same table.
        #[prost(message, tag = "1")]
        Table(super::BigQueryTable),
    }
}
/// Statistics regarding a specific InfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InfoTypeStats {
    /// The type of finding this stat is for.
    #[prost(message, optional, tag = "1")]
    pub info_type: ::core::option::Option<InfoType>,
    /// Number of findings for this infoType.
    #[prost(int64, tag = "2")]
    pub count: i64,
}
/// The results of an inspect DataSource job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectDataSourceDetails {
    /// The configuration used for this job.
    #[prost(message, optional, tag = "2")]
    pub requested_options: ::core::option::Option<inspect_data_source_details::RequestedOptions>,
    /// A summary of the outcome of this inspect job.
    #[prost(message, optional, tag = "3")]
    pub result: ::core::option::Option<inspect_data_source_details::Result>,
}
/// Nested message and enum types in `InspectDataSourceDetails`.
pub mod inspect_data_source_details {
    /// Snapshot of the inspection configuration.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RequestedOptions {
        /// If run with an InspectTemplate, a snapshot of its state at the time of
        /// this run.
        #[prost(message, optional, tag = "1")]
        pub snapshot_inspect_template: ::core::option::Option<super::InspectTemplate>,
        /// Inspect config.
        #[prost(message, optional, tag = "3")]
        pub job_config: ::core::option::Option<super::InspectJobConfig>,
    }
    /// All result fields mentioned below are updated while the job is processing.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Result {
        /// Total size in bytes that were processed.
        #[prost(int64, tag = "1")]
        pub processed_bytes: i64,
        /// Estimate of the number of bytes to process.
        #[prost(int64, tag = "2")]
        pub total_estimated_bytes: i64,
        /// Statistics of how many instances of each info type were found during
        /// inspect job.
        #[prost(message, repeated, tag = "3")]
        pub info_type_stats: ::prost::alloc::vec::Vec<super::InfoTypeStats>,
        /// Statistics related to the processing of hybrid inspect.
        /// Early access feature is in a pre-release state and might change or have
        /// limited support. For more information, see
        /// <https://cloud.google.com/products#product-launch-stages.>
        #[prost(message, optional, tag = "7")]
        pub hybrid_stats: ::core::option::Option<super::HybridInspectStatistics>,
    }
}
/// Statistics related to processing hybrid inspect requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridInspectStatistics {
    /// The number of hybrid inspection requests processed within this job.
    #[prost(int64, tag = "1")]
    pub processed_count: i64,
    /// The number of hybrid inspection requests aborted because the job ran
    /// out of quota or was ended before they could be processed.
    #[prost(int64, tag = "2")]
    pub aborted_count: i64,
    /// The number of hybrid requests currently being processed. Only populated
    /// when called via method `getDlpJob`.
    /// A burst of traffic may cause hybrid inspect requests to be enqueued.
    /// Processing will take place as quickly as possible, but resource limitations
    /// may impact how long a request is enqueued for.
    #[prost(int64, tag = "3")]
    pub pending_count: i64,
}
/// InfoType description.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InfoTypeDescription {
    /// Internal name of the infoType.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Human readable form of the infoType name.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Which parts of the API supports this InfoType.
    #[prost(enumeration = "InfoTypeSupportedBy", repeated, tag = "3")]
    pub supported_by: ::prost::alloc::vec::Vec<i32>,
    /// Description of the infotype. Translated when language is provided in the
    /// request.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
}
/// Request for the list of infoTypes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInfoTypesRequest {
    /// The parent resource name.
    ///
    /// The format of this value is as follows:
    ///
    ///     locations/<var>LOCATION_ID</var>
    #[prost(string, tag = "4")]
    pub parent: ::prost::alloc::string::String,
    /// BCP-47 language code for localized infoType friendly
    /// names. If omitted, or if localized strings are not available,
    /// en-US strings will be returned.
    #[prost(string, tag = "1")]
    pub language_code: ::prost::alloc::string::String,
    /// filter to only return infoTypes supported by certain parts of the
    /// API. Defaults to supported_by=INSPECT.
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "3")]
    pub location_id: ::prost::alloc::string::String,
}
/// Response to the ListInfoTypes request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInfoTypesResponse {
    /// Set of sensitive infoTypes.
    #[prost(message, repeated, tag = "1")]
    pub info_types: ::prost::alloc::vec::Vec<InfoTypeDescription>,
}
/// Configuration for a risk analysis job. See
/// <https://cloud.google.com/dlp/docs/concepts-risk-analysis> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RiskAnalysisJobConfig {
    /// Privacy metric to compute.
    #[prost(message, optional, tag = "1")]
    pub privacy_metric: ::core::option::Option<PrivacyMetric>,
    /// Input dataset to compute metrics over.
    #[prost(message, optional, tag = "2")]
    pub source_table: ::core::option::Option<BigQueryTable>,
    /// Actions to execute at the completion of the job. Are executed in the order
    /// provided.
    #[prost(message, repeated, tag = "3")]
    pub actions: ::prost::alloc::vec::Vec<Action>,
}
/// A column with a semantic tag attached.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuasiId {
    /// Required. Identifies the column.
    #[prost(message, optional, tag = "1")]
    pub field: ::core::option::Option<FieldId>,
    /// Semantic tag that identifies what a column contains, to determine which
    /// statistical model to use to estimate the reidentifiability of each
    /// value. \[required\]
    #[prost(oneof = "quasi_id::Tag", tags = "2, 3, 4")]
    pub tag: ::core::option::Option<quasi_id::Tag>,
}
/// Nested message and enum types in `QuasiId`.
pub mod quasi_id {
    /// Semantic tag that identifies what a column contains, to determine which
    /// statistical model to use to estimate the reidentifiability of each
    /// value. \[required\]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Tag {
        /// A column can be tagged with a InfoType to use the relevant public
        /// dataset as a statistical model of population, if available. We
        /// currently support US ZIP codes, region codes, ages and genders.
        /// To programmatically obtain the list of supported InfoTypes, use
        /// ListInfoTypes with the supported_by=RISK_ANALYSIS filter.
        #[prost(message, tag = "2")]
        InfoType(super::InfoType),
        /// A column can be tagged with a custom tag. In this case, the user must
        /// indicate an auxiliary table that contains statistical information on
        /// the possible values of this column (below).
        #[prost(string, tag = "3")]
        CustomTag(::prost::alloc::string::String),
        /// If no semantic tag is indicated, we infer the statistical model from
        /// the distribution of values in the input data
        #[prost(message, tag = "4")]
        Inferred(()),
    }
}
/// An auxiliary table containing statistical information on the relative
/// frequency of different quasi-identifiers values. It has one or several
/// quasi-identifiers columns, and one column that indicates the relative
/// frequency of each quasi-identifier tuple.
/// If a tuple is present in the data but not in the auxiliary table, the
/// corresponding relative frequency is assumed to be zero (and thus, the
/// tuple is highly reidentifiable).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StatisticalTable {
    /// Required. Auxiliary table location.
    #[prost(message, optional, tag = "3")]
    pub table: ::core::option::Option<BigQueryTable>,
    /// Required. Quasi-identifier columns.
    #[prost(message, repeated, tag = "1")]
    pub quasi_ids: ::prost::alloc::vec::Vec<statistical_table::QuasiIdentifierField>,
    /// Required. The relative frequency column must contain a floating-point number
    /// between 0 and 1 (inclusive). Null values are assumed to be zero.
    #[prost(message, optional, tag = "2")]
    pub relative_frequency: ::core::option::Option<FieldId>,
}
/// Nested message and enum types in `StatisticalTable`.
pub mod statistical_table {
    /// A quasi-identifier column has a custom_tag, used to know which column
    /// in the data corresponds to which column in the statistical model.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QuasiIdentifierField {
        /// Identifies the column.
        #[prost(message, optional, tag = "1")]
        pub field: ::core::option::Option<super::FieldId>,
        /// A column can be tagged with a custom tag. In this case, the user must
        /// indicate an auxiliary table that contains statistical information on
        /// the possible values of this column (below).
        #[prost(string, tag = "2")]
        pub custom_tag: ::prost::alloc::string::String,
    }
}
/// Privacy metric to compute for reidentification risk analysis.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrivacyMetric {
    /// Types of analysis.
    #[prost(oneof = "privacy_metric::Type", tags = "1, 2, 3, 4, 5, 6")]
    pub r#type: ::core::option::Option<privacy_metric::Type>,
}
/// Nested message and enum types in `PrivacyMetric`.
pub mod privacy_metric {
    /// Compute numerical stats over an individual column, including
    /// min, max, and quantiles.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NumericalStatsConfig {
        /// Field to compute numerical stats on. Supported types are
        /// integer, float, date, datetime, timestamp, time.
        #[prost(message, optional, tag = "1")]
        pub field: ::core::option::Option<super::FieldId>,
    }
    /// Compute numerical stats over an individual column, including
    /// number of distinct values and value count distribution.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CategoricalStatsConfig {
        /// Field to compute categorical stats on. All column types are
        /// supported except for arrays and structs. However, it may be more
        /// informative to use NumericalStats when the field type is supported,
        /// depending on the data.
        #[prost(message, optional, tag = "1")]
        pub field: ::core::option::Option<super::FieldId>,
    }
    /// k-anonymity metric, used for analysis of reidentification risk.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct KAnonymityConfig {
        /// Set of fields to compute k-anonymity over. When multiple fields are
        /// specified, they are considered a single composite key. Structs and
        /// repeated data types are not supported; however, nested fields are
        /// supported so long as they are not structs themselves or nested within
        /// a repeated field.
        #[prost(message, repeated, tag = "1")]
        pub quasi_ids: ::prost::alloc::vec::Vec<super::FieldId>,
        /// Message indicating that multiple rows might be associated to a
        /// single individual. If the same entity_id is associated to multiple
        /// quasi-identifier tuples over distinct rows, we consider the entire
        /// collection of tuples as the composite quasi-identifier. This collection
        /// is a multiset: the order in which the different tuples appear in the
        /// dataset is ignored, but their frequency is taken into account.
        ///
        /// Important note: a maximum of 1000 rows can be associated to a single
        /// entity ID. If more rows are associated with the same entity ID, some
        /// might be ignored.
        #[prost(message, optional, tag = "2")]
        pub entity_id: ::core::option::Option<super::EntityId>,
    }
    /// l-diversity metric, used for analysis of reidentification risk.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LDiversityConfig {
        /// Set of quasi-identifiers indicating how equivalence classes are
        /// defined for the l-diversity computation. When multiple fields are
        /// specified, they are considered a single composite key.
        #[prost(message, repeated, tag = "1")]
        pub quasi_ids: ::prost::alloc::vec::Vec<super::FieldId>,
        /// Sensitive field for computing the l-value.
        #[prost(message, optional, tag = "2")]
        pub sensitive_attribute: ::core::option::Option<super::FieldId>,
    }
    /// Reidentifiability metric. This corresponds to a risk model similar to what
    /// is called "journalist risk" in the literature, except the attack dataset is
    /// statistically modeled instead of being perfectly known. This can be done
    /// using publicly available data (like the US Census), or using a custom
    /// statistical model (indicated as one or several BigQuery tables), or by
    /// extrapolating from the distribution of values in the input dataset.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct KMapEstimationConfig {
        /// Required. Fields considered to be quasi-identifiers. No two columns can have the
        /// same tag.
        #[prost(message, repeated, tag = "1")]
        pub quasi_ids: ::prost::alloc::vec::Vec<k_map_estimation_config::TaggedField>,
        /// ISO 3166-1 alpha-2 region code to use in the statistical modeling.
        /// Set if no column is tagged with a region-specific InfoType (like
        /// US_ZIP_5) or a region code.
        #[prost(string, tag = "2")]
        pub region_code: ::prost::alloc::string::String,
        /// Several auxiliary tables can be used in the analysis. Each custom_tag
        /// used to tag a quasi-identifiers column must appear in exactly one column
        /// of one auxiliary table.
        #[prost(message, repeated, tag = "3")]
        pub auxiliary_tables: ::prost::alloc::vec::Vec<k_map_estimation_config::AuxiliaryTable>,
    }
    /// Nested message and enum types in `KMapEstimationConfig`.
    pub mod k_map_estimation_config {
        /// A column with a semantic tag attached.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct TaggedField {
            /// Required. Identifies the column.
            #[prost(message, optional, tag = "1")]
            pub field: ::core::option::Option<super::super::FieldId>,
            /// Semantic tag that identifies what a column contains, to determine which
            /// statistical model to use to estimate the reidentifiability of each
            /// value. \[required\]
            #[prost(oneof = "tagged_field::Tag", tags = "2, 3, 4")]
            pub tag: ::core::option::Option<tagged_field::Tag>,
        }
        /// Nested message and enum types in `TaggedField`.
        pub mod tagged_field {
            /// Semantic tag that identifies what a column contains, to determine which
            /// statistical model to use to estimate the reidentifiability of each
            /// value. \[required\]
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Tag {
                /// A column can be tagged with a InfoType to use the relevant public
                /// dataset as a statistical model of population, if available. We
                /// currently support US ZIP codes, region codes, ages and genders.
                /// To programmatically obtain the list of supported InfoTypes, use
                /// ListInfoTypes with the supported_by=RISK_ANALYSIS filter.
                #[prost(message, tag = "2")]
                InfoType(super::super::super::InfoType),
                /// A column can be tagged with a custom tag. In this case, the user must
                /// indicate an auxiliary table that contains statistical information on
                /// the possible values of this column (below).
                #[prost(string, tag = "3")]
                CustomTag(::prost::alloc::string::String),
                /// If no semantic tag is indicated, we infer the statistical model from
                /// the distribution of values in the input data
                #[prost(message, tag = "4")]
                Inferred(()),
            }
        }
        /// An auxiliary table contains statistical information on the relative
        /// frequency of different quasi-identifiers values. It has one or several
        /// quasi-identifiers columns, and one column that indicates the relative
        /// frequency of each quasi-identifier tuple.
        /// If a tuple is present in the data but not in the auxiliary table, the
        /// corresponding relative frequency is assumed to be zero (and thus, the
        /// tuple is highly reidentifiable).
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct AuxiliaryTable {
            /// Required. Auxiliary table location.
            #[prost(message, optional, tag = "3")]
            pub table: ::core::option::Option<super::super::BigQueryTable>,
            /// Required. Quasi-identifier columns.
            #[prost(message, repeated, tag = "1")]
            pub quasi_ids: ::prost::alloc::vec::Vec<auxiliary_table::QuasiIdField>,
            /// Required. The relative frequency column must contain a floating-point number
            /// between 0 and 1 (inclusive). Null values are assumed to be zero.
            #[prost(message, optional, tag = "2")]
            pub relative_frequency: ::core::option::Option<super::super::FieldId>,
        }
        /// Nested message and enum types in `AuxiliaryTable`.
        pub mod auxiliary_table {
            /// A quasi-identifier column has a custom_tag, used to know which column
            /// in the data corresponds to which column in the statistical model.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct QuasiIdField {
                /// Identifies the column.
                #[prost(message, optional, tag = "1")]
                pub field: ::core::option::Option<super::super::super::FieldId>,
                /// A auxiliary field.
                #[prost(string, tag = "2")]
                pub custom_tag: ::prost::alloc::string::String,
            }
        }
    }
    /// δ-presence metric, used to estimate how likely it is for an attacker to
    /// figure out that one given individual appears in a de-identified dataset.
    /// Similarly to the k-map metric, we cannot compute δ-presence exactly without
    /// knowing the attack dataset, so we use a statistical model instead.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DeltaPresenceEstimationConfig {
        /// Required. Fields considered to be quasi-identifiers. No two fields can have the
        /// same tag.
        #[prost(message, repeated, tag = "1")]
        pub quasi_ids: ::prost::alloc::vec::Vec<super::QuasiId>,
        /// ISO 3166-1 alpha-2 region code to use in the statistical modeling.
        /// Set if no column is tagged with a region-specific InfoType (like
        /// US_ZIP_5) or a region code.
        #[prost(string, tag = "2")]
        pub region_code: ::prost::alloc::string::String,
        /// Several auxiliary tables can be used in the analysis. Each custom_tag
        /// used to tag a quasi-identifiers field must appear in exactly one
        /// field of one auxiliary table.
        #[prost(message, repeated, tag = "3")]
        pub auxiliary_tables: ::prost::alloc::vec::Vec<super::StatisticalTable>,
    }
    /// Types of analysis.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Numerical stats
        #[prost(message, tag = "1")]
        NumericalStatsConfig(NumericalStatsConfig),
        /// Categorical stats
        #[prost(message, tag = "2")]
        CategoricalStatsConfig(CategoricalStatsConfig),
        /// K-anonymity
        #[prost(message, tag = "3")]
        KAnonymityConfig(KAnonymityConfig),
        /// l-diversity
        #[prost(message, tag = "4")]
        LDiversityConfig(LDiversityConfig),
        /// k-map
        #[prost(message, tag = "5")]
        KMapEstimationConfig(KMapEstimationConfig),
        /// delta-presence
        #[prost(message, tag = "6")]
        DeltaPresenceEstimationConfig(DeltaPresenceEstimationConfig),
    }
}
/// Result of a risk analysis operation request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyzeDataSourceRiskDetails {
    /// Privacy metric to compute.
    #[prost(message, optional, tag = "1")]
    pub requested_privacy_metric: ::core::option::Option<PrivacyMetric>,
    /// Input dataset to compute metrics over.
    #[prost(message, optional, tag = "2")]
    pub requested_source_table: ::core::option::Option<BigQueryTable>,
    /// The configuration used for this job.
    #[prost(message, optional, tag = "10")]
    pub requested_options:
        ::core::option::Option<analyze_data_source_risk_details::RequestedRiskAnalysisOptions>,
    /// Values associated with this metric.
    #[prost(oneof = "analyze_data_source_risk_details::Result", tags = "3, 4, 5, 6, 7, 9")]
    pub result: ::core::option::Option<analyze_data_source_risk_details::Result>,
}
/// Nested message and enum types in `AnalyzeDataSourceRiskDetails`.
pub mod analyze_data_source_risk_details {
    /// Result of the numerical stats computation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NumericalStatsResult {
        /// Minimum value appearing in the column.
        #[prost(message, optional, tag = "1")]
        pub min_value: ::core::option::Option<super::Value>,
        /// Maximum value appearing in the column.
        #[prost(message, optional, tag = "2")]
        pub max_value: ::core::option::Option<super::Value>,
        /// List of 99 values that partition the set of field values into 100 equal
        /// sized buckets.
        #[prost(message, repeated, tag = "4")]
        pub quantile_values: ::prost::alloc::vec::Vec<super::Value>,
    }
    /// Result of the categorical stats computation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CategoricalStatsResult {
        /// Histogram of value frequencies in the column.
        #[prost(message, repeated, tag = "5")]
        pub value_frequency_histogram_buckets:
            ::prost::alloc::vec::Vec<categorical_stats_result::CategoricalStatsHistogramBucket>,
    }
    /// Nested message and enum types in `CategoricalStatsResult`.
    pub mod categorical_stats_result {
        /// Histogram of value frequencies in the column.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct CategoricalStatsHistogramBucket {
            /// Lower bound on the value frequency of the values in this bucket.
            #[prost(int64, tag = "1")]
            pub value_frequency_lower_bound: i64,
            /// Upper bound on the value frequency of the values in this bucket.
            #[prost(int64, tag = "2")]
            pub value_frequency_upper_bound: i64,
            /// Total number of values in this bucket.
            #[prost(int64, tag = "3")]
            pub bucket_size: i64,
            /// Sample of value frequencies in this bucket. The total number of
            /// values returned per bucket is capped at 20.
            #[prost(message, repeated, tag = "4")]
            pub bucket_values: ::prost::alloc::vec::Vec<super::super::ValueFrequency>,
            /// Total number of distinct values in this bucket.
            #[prost(int64, tag = "5")]
            pub bucket_value_count: i64,
        }
    }
    /// Result of the k-anonymity computation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct KAnonymityResult {
        /// Histogram of k-anonymity equivalence classes.
        #[prost(message, repeated, tag = "5")]
        pub equivalence_class_histogram_buckets:
            ::prost::alloc::vec::Vec<k_anonymity_result::KAnonymityHistogramBucket>,
    }
    /// Nested message and enum types in `KAnonymityResult`.
    pub mod k_anonymity_result {
        /// The set of columns' values that share the same ldiversity value
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct KAnonymityEquivalenceClass {
            /// Set of values defining the equivalence class. One value per
            /// quasi-identifier column in the original KAnonymity metric message.
            /// The order is always the same as the original request.
            #[prost(message, repeated, tag = "1")]
            pub quasi_ids_values: ::prost::alloc::vec::Vec<super::super::Value>,
            /// Size of the equivalence class, for example number of rows with the
            /// above set of values.
            #[prost(int64, tag = "2")]
            pub equivalence_class_size: i64,
        }
        /// Histogram of k-anonymity equivalence classes.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct KAnonymityHistogramBucket {
            /// Lower bound on the size of the equivalence classes in this bucket.
            #[prost(int64, tag = "1")]
            pub equivalence_class_size_lower_bound: i64,
            /// Upper bound on the size of the equivalence classes in this bucket.
            #[prost(int64, tag = "2")]
            pub equivalence_class_size_upper_bound: i64,
            /// Total number of equivalence classes in this bucket.
            #[prost(int64, tag = "3")]
            pub bucket_size: i64,
            /// Sample of equivalence classes in this bucket. The total number of
            /// classes returned per bucket is capped at 20.
            #[prost(message, repeated, tag = "4")]
            pub bucket_values: ::prost::alloc::vec::Vec<KAnonymityEquivalenceClass>,
            /// Total number of distinct equivalence classes in this bucket.
            #[prost(int64, tag = "5")]
            pub bucket_value_count: i64,
        }
    }
    /// Result of the l-diversity computation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LDiversityResult {
        /// Histogram of l-diversity equivalence class sensitive value frequencies.
        #[prost(message, repeated, tag = "5")]
        pub sensitive_value_frequency_histogram_buckets:
            ::prost::alloc::vec::Vec<l_diversity_result::LDiversityHistogramBucket>,
    }
    /// Nested message and enum types in `LDiversityResult`.
    pub mod l_diversity_result {
        /// The set of columns' values that share the same ldiversity value.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct LDiversityEquivalenceClass {
            /// Quasi-identifier values defining the k-anonymity equivalence
            /// class. The order is always the same as the original request.
            #[prost(message, repeated, tag = "1")]
            pub quasi_ids_values: ::prost::alloc::vec::Vec<super::super::Value>,
            /// Size of the k-anonymity equivalence class.
            #[prost(int64, tag = "2")]
            pub equivalence_class_size: i64,
            /// Number of distinct sensitive values in this equivalence class.
            #[prost(int64, tag = "3")]
            pub num_distinct_sensitive_values: i64,
            /// Estimated frequencies of top sensitive values.
            #[prost(message, repeated, tag = "4")]
            pub top_sensitive_values: ::prost::alloc::vec::Vec<super::super::ValueFrequency>,
        }
        /// Histogram of l-diversity equivalence class sensitive value frequencies.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct LDiversityHistogramBucket {
            /// Lower bound on the sensitive value frequencies of the equivalence
            /// classes in this bucket.
            #[prost(int64, tag = "1")]
            pub sensitive_value_frequency_lower_bound: i64,
            /// Upper bound on the sensitive value frequencies of the equivalence
            /// classes in this bucket.
            #[prost(int64, tag = "2")]
            pub sensitive_value_frequency_upper_bound: i64,
            /// Total number of equivalence classes in this bucket.
            #[prost(int64, tag = "3")]
            pub bucket_size: i64,
            /// Sample of equivalence classes in this bucket. The total number of
            /// classes returned per bucket is capped at 20.
            #[prost(message, repeated, tag = "4")]
            pub bucket_values: ::prost::alloc::vec::Vec<LDiversityEquivalenceClass>,
            /// Total number of distinct equivalence classes in this bucket.
            #[prost(int64, tag = "5")]
            pub bucket_value_count: i64,
        }
    }
    /// Result of the reidentifiability analysis. Note that these results are an
    /// estimation, not exact values.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct KMapEstimationResult {
        /// The intervals [min_anonymity, max_anonymity] do not overlap. If a value
        /// doesn't correspond to any such interval, the associated frequency is
        /// zero. For example, the following records:
        ///   {min_anonymity: 1, max_anonymity: 1, frequency: 17}
        ///   {min_anonymity: 2, max_anonymity: 3, frequency: 42}
        ///   {min_anonymity: 5, max_anonymity: 10, frequency: 99}
        /// mean that there are no record with an estimated anonymity of 4, 5, or
        /// larger than 10.
        #[prost(message, repeated, tag = "1")]
        pub k_map_estimation_histogram:
            ::prost::alloc::vec::Vec<k_map_estimation_result::KMapEstimationHistogramBucket>,
    }
    /// Nested message and enum types in `KMapEstimationResult`.
    pub mod k_map_estimation_result {
        /// A tuple of values for the quasi-identifier columns.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct KMapEstimationQuasiIdValues {
            /// The quasi-identifier values.
            #[prost(message, repeated, tag = "1")]
            pub quasi_ids_values: ::prost::alloc::vec::Vec<super::super::Value>,
            /// The estimated anonymity for these quasi-identifier values.
            #[prost(int64, tag = "2")]
            pub estimated_anonymity: i64,
        }
        /// A KMapEstimationHistogramBucket message with the following values:
        ///   min_anonymity: 3
        ///   max_anonymity: 5
        ///   frequency: 42
        /// means that there are 42 records whose quasi-identifier values correspond
        /// to 3, 4 or 5 people in the overlying population. An important particular
        /// case is when min_anonymity = max_anonymity = 1: the frequency field then
        /// corresponds to the number of uniquely identifiable records.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct KMapEstimationHistogramBucket {
            /// Always positive.
            #[prost(int64, tag = "1")]
            pub min_anonymity: i64,
            /// Always greater than or equal to min_anonymity.
            #[prost(int64, tag = "2")]
            pub max_anonymity: i64,
            /// Number of records within these anonymity bounds.
            #[prost(int64, tag = "5")]
            pub bucket_size: i64,
            /// Sample of quasi-identifier tuple values in this bucket. The total
            /// number of classes returned per bucket is capped at 20.
            #[prost(message, repeated, tag = "6")]
            pub bucket_values: ::prost::alloc::vec::Vec<KMapEstimationQuasiIdValues>,
            /// Total number of distinct quasi-identifier tuple values in this bucket.
            #[prost(int64, tag = "7")]
            pub bucket_value_count: i64,
        }
    }
    /// Result of the δ-presence computation. Note that these results are an
    /// estimation, not exact values.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DeltaPresenceEstimationResult {
        /// The intervals [min_probability, max_probability) do not overlap. If a
        /// value doesn't correspond to any such interval, the associated frequency
        /// is zero. For example, the following records:
        ///   {min_probability: 0, max_probability: 0.1, frequency: 17}
        ///   {min_probability: 0.2, max_probability: 0.3, frequency: 42}
        ///   {min_probability: 0.3, max_probability: 0.4, frequency: 99}
        /// mean that there are no record with an estimated probability in [0.1, 0.2)
        /// nor larger or equal to 0.4.
        #[prost(message, repeated, tag = "1")]
        pub delta_presence_estimation_histogram: ::prost::alloc::vec::Vec<
            delta_presence_estimation_result::DeltaPresenceEstimationHistogramBucket,
        >,
    }
    /// Nested message and enum types in `DeltaPresenceEstimationResult`.
    pub mod delta_presence_estimation_result {
        /// A tuple of values for the quasi-identifier columns.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct DeltaPresenceEstimationQuasiIdValues {
            /// The quasi-identifier values.
            #[prost(message, repeated, tag = "1")]
            pub quasi_ids_values: ::prost::alloc::vec::Vec<super::super::Value>,
            /// The estimated probability that a given individual sharing these
            /// quasi-identifier values is in the dataset. This value, typically called
            /// δ, is the ratio between the number of records in the dataset with these
            /// quasi-identifier values, and the total number of individuals (inside
            /// *and* outside the dataset) with these quasi-identifier values.
            /// For example, if there are 15 individuals in the dataset who share the
            /// same quasi-identifier values, and an estimated 100 people in the entire
            /// population with these values, then δ is 0.15.
            #[prost(double, tag = "2")]
            pub estimated_probability: f64,
        }
        /// A DeltaPresenceEstimationHistogramBucket message with the following
        /// values:
        ///   min_probability: 0.1
        ///   max_probability: 0.2
        ///   frequency: 42
        /// means that there are 42 records for which δ is in [0.1, 0.2). An
        /// important particular case is when min_probability = max_probability = 1:
        /// then, every individual who shares this quasi-identifier combination is in
        /// the dataset.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct DeltaPresenceEstimationHistogramBucket {
            /// Between 0 and 1.
            #[prost(double, tag = "1")]
            pub min_probability: f64,
            /// Always greater than or equal to min_probability.
            #[prost(double, tag = "2")]
            pub max_probability: f64,
            /// Number of records within these probability bounds.
            #[prost(int64, tag = "5")]
            pub bucket_size: i64,
            /// Sample of quasi-identifier tuple values in this bucket. The total
            /// number of classes returned per bucket is capped at 20.
            #[prost(message, repeated, tag = "6")]
            pub bucket_values: ::prost::alloc::vec::Vec<DeltaPresenceEstimationQuasiIdValues>,
            /// Total number of distinct quasi-identifier tuple values in this bucket.
            #[prost(int64, tag = "7")]
            pub bucket_value_count: i64,
        }
    }
    /// Risk analysis options.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RequestedRiskAnalysisOptions {
        /// The job config for the risk job.
        #[prost(message, optional, tag = "1")]
        pub job_config: ::core::option::Option<super::RiskAnalysisJobConfig>,
    }
    /// Values associated with this metric.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        /// Numerical stats result
        #[prost(message, tag = "3")]
        NumericalStatsResult(NumericalStatsResult),
        /// Categorical stats result
        #[prost(message, tag = "4")]
        CategoricalStatsResult(CategoricalStatsResult),
        /// K-anonymity result
        #[prost(message, tag = "5")]
        KAnonymityResult(KAnonymityResult),
        /// L-divesity result
        #[prost(message, tag = "6")]
        LDiversityResult(LDiversityResult),
        /// K-map result
        #[prost(message, tag = "7")]
        KMapEstimationResult(KMapEstimationResult),
        /// Delta-presence result
        #[prost(message, tag = "9")]
        DeltaPresenceEstimationResult(DeltaPresenceEstimationResult),
    }
}
/// A value of a field, including its frequency.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ValueFrequency {
    /// A value contained in the field in question.
    #[prost(message, optional, tag = "1")]
    pub value: ::core::option::Option<Value>,
    /// How many times the value is contained in the field.
    #[prost(int64, tag = "2")]
    pub count: i64,
}
/// Set of primitive values supported by the system.
/// Note that for the purposes of inspection or transformation, the number
/// of bytes considered to comprise a 'Value' is based on its representation
/// as a UTF-8 encoded string. For example, if 'integer_value' is set to
/// 123456789, the number of bytes would be counted as 9, even though an
/// int64 only holds up to 8 bytes of data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Value {
    /// Value types
    #[prost(oneof = "value::Type", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
    pub r#type: ::core::option::Option<value::Type>,
}
/// Nested message and enum types in `Value`.
pub mod value {
    /// Value types
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// integer
        #[prost(int64, tag = "1")]
        IntegerValue(i64),
        /// float
        #[prost(double, tag = "2")]
        FloatValue(f64),
        /// string
        #[prost(string, tag = "3")]
        StringValue(::prost::alloc::string::String),
        /// boolean
        #[prost(bool, tag = "4")]
        BooleanValue(bool),
        /// timestamp
        #[prost(message, tag = "5")]
        TimestampValue(::prost_types::Timestamp),
        /// time of day
        #[prost(message, tag = "6")]
        TimeValue(super::super::super::super::r#type::TimeOfDay),
        /// date
        #[prost(message, tag = "7")]
        DateValue(super::super::super::super::r#type::Date),
        /// day of week
        #[prost(enumeration = "super::super::super::super::r#type::DayOfWeek", tag = "8")]
        DayOfWeekValue(i32),
    }
}
/// Message for infoType-dependent details parsed from quote.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuoteInfo {
    /// Object representation of the quote.
    #[prost(oneof = "quote_info::ParsedQuote", tags = "2")]
    pub parsed_quote: ::core::option::Option<quote_info::ParsedQuote>,
}
/// Nested message and enum types in `QuoteInfo`.
pub mod quote_info {
    /// Object representation of the quote.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParsedQuote {
        /// The date time indicated by the quote.
        #[prost(message, tag = "2")]
        DateTime(super::DateTime),
    }
}
/// Message for a date time object.
/// e.g. 2018-01-01, 5th August.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DateTime {
    /// One or more of the following must be set.
    /// Must be a valid date or time value.
    #[prost(message, optional, tag = "1")]
    pub date: ::core::option::Option<super::super::super::r#type::Date>,
    /// Day of week
    #[prost(enumeration = "super::super::super::r#type::DayOfWeek", tag = "2")]
    pub day_of_week: i32,
    /// Time of day
    #[prost(message, optional, tag = "3")]
    pub time: ::core::option::Option<super::super::super::r#type::TimeOfDay>,
    /// Time zone
    #[prost(message, optional, tag = "4")]
    pub time_zone: ::core::option::Option<date_time::TimeZone>,
}
/// Nested message and enum types in `DateTime`.
pub mod date_time {
    /// Time zone of the date time object.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TimeZone {
        /// Set only if the offset can be determined. Positive for time ahead of UTC.
        /// E.g. For "UTC-9", this value is -540.
        #[prost(int32, tag = "1")]
        pub offset_minutes: i32,
    }
}
/// The configuration that controls how the data will change.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeidentifyConfig {
    /// Mode for handling transformation errors. If left unspecified, the default
    /// mode is `TransformationErrorHandling.ThrowError`.
    #[prost(message, optional, tag = "3")]
    pub transformation_error_handling: ::core::option::Option<TransformationErrorHandling>,
    #[prost(oneof = "deidentify_config::Transformation", tags = "1, 2")]
    pub transformation: ::core::option::Option<deidentify_config::Transformation>,
}
/// Nested message and enum types in `DeidentifyConfig`.
pub mod deidentify_config {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Transformation {
        /// Treat the dataset as free-form text and apply the same free text
        /// transformation everywhere.
        #[prost(message, tag = "1")]
        InfoTypeTransformations(super::InfoTypeTransformations),
        /// Treat the dataset as structured. Transformations can be applied to
        /// specific locations within structured datasets, such as transforming
        /// a column within a table.
        #[prost(message, tag = "2")]
        RecordTransformations(super::RecordTransformations),
    }
}
/// How to handle transformation errors during de-identification. A
/// transformation error occurs when the requested transformation is incompatible
/// with the data. For example, trying to de-identify an IP address using a
/// `DateShift` transformation would result in a transformation error, since date
/// info cannot be extracted from an IP address.
/// Information about any incompatible transformations, and how they were
/// handled, is returned in the response as part of the
/// `TransformationOverviews`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransformationErrorHandling {
    /// How transformation errors should be handled.
    #[prost(oneof = "transformation_error_handling::Mode", tags = "1, 2")]
    pub mode: ::core::option::Option<transformation_error_handling::Mode>,
}
/// Nested message and enum types in `TransformationErrorHandling`.
pub mod transformation_error_handling {
    /// Throw an error and fail the request when a transformation error occurs.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ThrowError {}
    /// Skips the data without modifying it if the requested transformation would
    /// cause an error. For example, if a `DateShift` transformation were applied
    /// an an IP address, this mode would leave the IP address unchanged in the
    /// response.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LeaveUntransformed {}
    /// How transformation errors should be handled.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Mode {
        /// Throw an error
        #[prost(message, tag = "1")]
        ThrowError(ThrowError),
        /// Ignore errors
        #[prost(message, tag = "2")]
        LeaveUntransformed(LeaveUntransformed),
    }
}
/// A rule for transforming a value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrimitiveTransformation {
    #[prost(
        oneof = "primitive_transformation::Transformation",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12"
    )]
    pub transformation: ::core::option::Option<primitive_transformation::Transformation>,
}
/// Nested message and enum types in `PrimitiveTransformation`.
pub mod primitive_transformation {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Transformation {
        /// Replace
        #[prost(message, tag = "1")]
        ReplaceConfig(super::ReplaceValueConfig),
        /// Redact
        #[prost(message, tag = "2")]
        RedactConfig(super::RedactConfig),
        /// Mask
        #[prost(message, tag = "3")]
        CharacterMaskConfig(super::CharacterMaskConfig),
        /// Ffx-Fpe
        #[prost(message, tag = "4")]
        CryptoReplaceFfxFpeConfig(super::CryptoReplaceFfxFpeConfig),
        /// Fixed size bucketing
        #[prost(message, tag = "5")]
        FixedSizeBucketingConfig(super::FixedSizeBucketingConfig),
        /// Bucketing
        #[prost(message, tag = "6")]
        BucketingConfig(super::BucketingConfig),
        /// Replace with infotype
        #[prost(message, tag = "7")]
        ReplaceWithInfoTypeConfig(super::ReplaceWithInfoTypeConfig),
        /// Time extraction
        #[prost(message, tag = "8")]
        TimePartConfig(super::TimePartConfig),
        /// Crypto
        #[prost(message, tag = "9")]
        CryptoHashConfig(super::CryptoHashConfig),
        /// Date Shift
        #[prost(message, tag = "11")]
        DateShiftConfig(super::DateShiftConfig),
        /// Deterministic Crypto
        #[prost(message, tag = "12")]
        CryptoDeterministicConfig(super::CryptoDeterministicConfig),
    }
}
/// For use with `Date`, `Timestamp`, and `TimeOfDay`, extract or preserve a
/// portion of the value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimePartConfig {
    /// The part of the time to keep.
    #[prost(enumeration = "time_part_config::TimePart", tag = "1")]
    pub part_to_extract: i32,
}
/// Nested message and enum types in `TimePartConfig`.
pub mod time_part_config {
    /// Components that make up time.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TimePart {
        /// Unused
        Unspecified = 0,
        /// \[0-9999\]
        Year = 1,
        /// \[1-12\]
        Month = 2,
        /// \[1-31\]
        DayOfMonth = 3,
        /// \[1-7\]
        DayOfWeek = 4,
        /// \[1-53\]
        WeekOfYear = 5,
        /// \[0-23\]
        HourOfDay = 6,
    }
}
/// Pseudonymization method that generates surrogates via cryptographic hashing.
/// Uses SHA-256.
/// The key size must be either 32 or 64 bytes.
/// Outputs a base64 encoded representation of the hashed output
/// (for example, L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=).
/// Currently, only string and integer values can be hashed.
/// See <https://cloud.google.com/dlp/docs/pseudonymization> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CryptoHashConfig {
    /// The key used by the hash function.
    #[prost(message, optional, tag = "1")]
    pub crypto_key: ::core::option::Option<CryptoKey>,
}
/// Pseudonymization method that generates deterministic encryption for the given
/// input. Outputs a base64 encoded representation of the encrypted output.
/// Uses AES-SIV based on the RFC <https://tools.ietf.org/html/rfc5297.>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CryptoDeterministicConfig {
    /// The key used by the encryption function.
    #[prost(message, optional, tag = "1")]
    pub crypto_key: ::core::option::Option<CryptoKey>,
    /// The custom info type to annotate the surrogate with.
    /// This annotation will be applied to the surrogate by prefixing it with
    /// the name of the custom info type followed by the number of
    /// characters comprising the surrogate. The following scheme defines the
    /// format: {info type name}({surrogate character count}):{surrogate}
    ///
    /// For example, if the name of custom info type is 'MY_TOKEN_INFO_TYPE' and
    /// the surrogate is 'abc', the full replacement value
    /// will be: 'MY_TOKEN_INFO_TYPE(3):abc'
    ///
    /// This annotation identifies the surrogate when inspecting content using the
    /// custom info type 'Surrogate'. This facilitates reversal of the
    /// surrogate when it occurs in free text.
    ///
    /// Note: For record transformations where the entire cell in a table is being
    /// transformed, surrogates are not mandatory. Surrogates are used to denote
    /// the location of the token and are necessary for re-identification in free
    /// form text.
    ///
    /// In order for inspection to work properly, the name of this info type must
    /// not occur naturally anywhere in your data; otherwise, inspection may either
    ///
    /// - reverse a surrogate that does not correspond to an actual identifier
    /// - be unable to parse the surrogate and result in an error
    ///
    /// Therefore, choose your custom info type name carefully after considering
    /// what your data looks like. One way to select a name that has a high chance
    /// of yielding reliable detection is to include one or more unicode characters
    /// that are highly improbable to exist in your data.
    /// For example, assuming your data is entered from a regular ASCII keyboard,
    /// the symbol with the hex code point 29DD might be used like so:
    /// ⧝MY_TOKEN_TYPE.
    #[prost(message, optional, tag = "2")]
    pub surrogate_info_type: ::core::option::Option<InfoType>,
    /// A context may be used for higher security and maintaining
    /// referential integrity such that the same identifier in two different
    /// contexts will be given a distinct surrogate. The context is appended to
    /// plaintext value being encrypted. On decryption the provided context is
    /// validated against the value used during encryption. If a context was
    /// provided during encryption, same context must be provided during decryption
    /// as well.
    ///
    /// If the context is not set, plaintext would be used as is for encryption.
    /// If the context is set but:
    ///
    /// 1. there is no record present when transforming a given value or
    /// 2. the field is not present when transforming a given value,
    ///
    /// plaintext would be used as is for encryption.
    ///
    /// Note that case (1) is expected when an `InfoTypeTransformation` is
    /// applied to both structured and non-structured `ContentItem`s.
    #[prost(message, optional, tag = "3")]
    pub context: ::core::option::Option<FieldId>,
}
/// Replace each input value with a given `Value`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReplaceValueConfig {
    /// Value to replace it with.
    #[prost(message, optional, tag = "1")]
    pub new_value: ::core::option::Option<Value>,
}
/// Replace each matching finding with the name of the info_type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReplaceWithInfoTypeConfig {}
/// Redact a given value. For example, if used with an `InfoTypeTransformation`
/// transforming PHONE_NUMBER, and input 'My phone number is 206-555-0123', the
/// output would be 'My phone number is '.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedactConfig {}
/// Characters to skip when doing deidentification of a value. These will be left
/// alone and skipped.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CharsToIgnore {
    #[prost(oneof = "chars_to_ignore::Characters", tags = "1, 2")]
    pub characters: ::core::option::Option<chars_to_ignore::Characters>,
}
/// Nested message and enum types in `CharsToIgnore`.
pub mod chars_to_ignore {
    /// Convenience enum for indication common characters to not transform.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum CommonCharsToIgnore {
        /// Unused.
        Unspecified = 0,
        /// 0-9
        Numeric = 1,
        /// A-Z
        AlphaUpperCase = 2,
        /// a-z
        AlphaLowerCase = 3,
        /// US Punctuation, one of !"#$%&'()*+,-./:;<=>?@\[\\]^_`{|}~
        Punctuation = 4,
        /// Whitespace character, one of [ \t\n\x0B\f\r]
        Whitespace = 5,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Characters {
        /// Characters to not transform when masking.
        #[prost(string, tag = "1")]
        CharactersToSkip(::prost::alloc::string::String),
        /// Common characters to not transform when masking. Useful to avoid removing
        /// punctuation.
        #[prost(enumeration = "CommonCharsToIgnore", tag = "2")]
        CommonCharactersToIgnore(i32),
    }
}
/// Partially mask a string by replacing a given number of characters with a
/// fixed character. Masking can start from the beginning or end of the string.
/// This can be used on data of any type (numbers, longs, and so on) and when
/// de-identifying structured data we'll attempt to preserve the original data's
/// type. (This allows you to take a long like 123 and modify it to a string like
/// **3.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CharacterMaskConfig {
    /// Character to use to mask the sensitive values&mdash;for example, `*` for an
    /// alphabetic string such as a name, or `0` for a numeric string such as ZIP
    /// code or credit card number. This string must have a length of 1. If not
    /// supplied, this value defaults to `*` for strings, and `0` for digits.
    #[prost(string, tag = "1")]
    pub masking_character: ::prost::alloc::string::String,
    /// Number of characters to mask. If not set, all matching chars will be
    /// masked. Skipped characters do not count towards this tally.
    #[prost(int32, tag = "2")]
    pub number_to_mask: i32,
    /// Mask characters in reverse order. For example, if `masking_character` is
    /// `0`, `number_to_mask` is `14`, and `reverse_order` is `false`, then the
    /// input string `1234-5678-9012-3456` is masked as `00000000000000-3456`.
    /// If `masking_character` is `*`, `number_to_mask` is `3`, and `reverse_order`
    /// is `true`, then the string `12345` is masked as `12***`.
    #[prost(bool, tag = "3")]
    pub reverse_order: bool,
    /// When masking a string, items in this list will be skipped when replacing
    /// characters. For example, if the input string is `555-555-5555` and you
    /// instruct Cloud DLP to skip `-` and mask 5 characters with `*`, Cloud DLP
    /// returns `***-**5-5555`.
    #[prost(message, repeated, tag = "4")]
    pub characters_to_ignore: ::prost::alloc::vec::Vec<CharsToIgnore>,
}
/// Buckets values based on fixed size ranges. The
/// Bucketing transformation can provide all of this functionality,
/// but requires more configuration. This message is provided as a convenience to
/// the user for simple bucketing strategies.
///
/// The transformed value will be a hyphenated string of
/// {lower_bound}-{upper_bound}, i.e if lower_bound = 10 and upper_bound = 20
/// all values that are within this bucket will be replaced with "10-20".
///
/// This can be used on data of type: double, long.
///
/// If the bound Value type differs from the type of data
/// being transformed, we will first attempt converting the type of the data to
/// be transformed to match the type of the bound before comparing.
///
/// See <https://cloud.google.com/dlp/docs/concepts-bucketing> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FixedSizeBucketingConfig {
    /// Required. Lower bound value of buckets. All values less than `lower_bound` are
    /// grouped together into a single bucket; for example if `lower_bound` = 10,
    /// then all values less than 10 are replaced with the value "-10".
    #[prost(message, optional, tag = "1")]
    pub lower_bound: ::core::option::Option<Value>,
    /// Required. Upper bound value of buckets. All values greater than upper_bound are
    /// grouped together into a single bucket; for example if `upper_bound` = 89,
    /// then all values greater than 89 are replaced with the value "89+".
    #[prost(message, optional, tag = "2")]
    pub upper_bound: ::core::option::Option<Value>,
    /// Required. Size of each bucket (except for minimum and maximum buckets). So if
    /// `lower_bound` = 10, `upper_bound` = 89, and `bucket_size` = 10, then the
    /// following buckets would be used: -10, 10-20, 20-30, 30-40, 40-50, 50-60,
    /// 60-70, 70-80, 80-89, 89+. Precision up to 2 decimals works.
    #[prost(double, tag = "3")]
    pub bucket_size: f64,
}
/// Generalization function that buckets values based on ranges. The ranges and
/// replacement values are dynamically provided by the user for custom behavior,
/// such as 1-30 -> LOW 31-65 -> MEDIUM 66-100 -> HIGH
/// This can be used on
/// data of type: number, long, string, timestamp.
/// If the bound `Value` type differs from the type of data being transformed, we
/// will first attempt converting the type of the data to be transformed to match
/// the type of the bound before comparing.
/// See <https://cloud.google.com/dlp/docs/concepts-bucketing> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BucketingConfig {
    /// Set of buckets. Ranges must be non-overlapping.
    #[prost(message, repeated, tag = "1")]
    pub buckets: ::prost::alloc::vec::Vec<bucketing_config::Bucket>,
}
/// Nested message and enum types in `BucketingConfig`.
pub mod bucketing_config {
    /// Bucket is represented as a range, along with replacement values.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Bucket {
        /// Lower bound of the range, inclusive. Type should be the same as max if
        /// used.
        #[prost(message, optional, tag = "1")]
        pub min: ::core::option::Option<super::Value>,
        /// Upper bound of the range, exclusive; type must match min.
        #[prost(message, optional, tag = "2")]
        pub max: ::core::option::Option<super::Value>,
        /// Required. Replacement value for this bucket.
        #[prost(message, optional, tag = "3")]
        pub replacement_value: ::core::option::Option<super::Value>,
    }
}
/// Replaces an identifier with a surrogate using Format Preserving Encryption
/// (FPE) with the FFX mode of operation; however when used in the
/// `ReidentifyContent` API method, it serves the opposite function by reversing
/// the surrogate back into the original identifier. The identifier must be
/// encoded as ASCII. For a given crypto key and context, the same identifier
/// will be replaced with the same surrogate. Identifiers must be at least two
/// characters long. In the case that the identifier is the empty string, it will
/// be skipped. See <https://cloud.google.com/dlp/docs/pseudonymization> to learn
/// more.
///
/// Note: We recommend using  CryptoDeterministicConfig for all use cases which
/// do not require preserving the input alphabet space and size, plus warrant
/// referential integrity.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CryptoReplaceFfxFpeConfig {
    /// Required. The key used by the encryption algorithm.
    #[prost(message, optional, tag = "1")]
    pub crypto_key: ::core::option::Option<CryptoKey>,
    /// The 'tweak', a context may be used for higher security since the same
    /// identifier in two different contexts won't be given the same surrogate. If
    /// the context is not set, a default tweak will be used.
    ///
    /// If the context is set but:
    ///
    /// 1. there is no record present when transforming a given value or
    /// 1. the field is not present when transforming a given value,
    ///
    /// a default tweak will be used.
    ///
    /// Note that case (1) is expected when an `InfoTypeTransformation` is
    /// applied to both structured and non-structured `ContentItem`s.
    /// Currently, the referenced field may be of value type integer or string.
    ///
    /// The tweak is constructed as a sequence of bytes in big endian byte order
    /// such that:
    ///
    /// - a 64 bit integer is encoded followed by a single byte of value 1
    /// - a string is encoded in UTF-8 format followed by a single byte of value 2
    #[prost(message, optional, tag = "2")]
    pub context: ::core::option::Option<FieldId>,
    /// The custom infoType to annotate the surrogate with.
    /// This annotation will be applied to the surrogate by prefixing it with
    /// the name of the custom infoType followed by the number of
    /// characters comprising the surrogate. The following scheme defines the
    /// format: info_type_name(surrogate_character_count):surrogate
    ///
    /// For example, if the name of custom infoType is 'MY_TOKEN_INFO_TYPE' and
    /// the surrogate is 'abc', the full replacement value
    /// will be: 'MY_TOKEN_INFO_TYPE(3):abc'
    ///
    /// This annotation identifies the surrogate when inspecting content using the
    /// custom infoType
    /// \[`SurrogateType`\](<https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype>).
    /// This facilitates reversal of the surrogate when it occurs in free text.
    ///
    /// In order for inspection to work properly, the name of this infoType must
    /// not occur naturally anywhere in your data; otherwise, inspection may
    /// find a surrogate that does not correspond to an actual identifier.
    /// Therefore, choose your custom infoType name carefully after considering
    /// what your data looks like. One way to select a name that has a high chance
    /// of yielding reliable detection is to include one or more unicode characters
    /// that are highly improbable to exist in your data.
    /// For example, assuming your data is entered from a regular ASCII keyboard,
    /// the symbol with the hex code point 29DD might be used like so:
    /// ⧝MY_TOKEN_TYPE
    #[prost(message, optional, tag = "8")]
    pub surrogate_info_type: ::core::option::Option<InfoType>,
    /// Choose an alphabet which the data being transformed will be made up of.
    #[prost(oneof = "crypto_replace_ffx_fpe_config::Alphabet", tags = "4, 5, 6")]
    pub alphabet: ::core::option::Option<crypto_replace_ffx_fpe_config::Alphabet>,
}
/// Nested message and enum types in `CryptoReplaceFfxFpeConfig`.
pub mod crypto_replace_ffx_fpe_config {
    /// These are commonly used subsets of the alphabet that the FFX mode
    /// natively supports. In the algorithm, the alphabet is selected using
    /// the "radix". Therefore each corresponds to particular radix.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum FfxCommonNativeAlphabet {
        /// Unused.
        Unspecified = 0,
        /// `\[0-9\]` (radix of 10)
        Numeric = 1,
        /// `\[0-9A-F\]` (radix of 16)
        Hexadecimal = 2,
        /// `\[0-9A-Z\]` (radix of 36)
        UpperCaseAlphaNumeric = 3,
        /// `\[0-9A-Za-z\]` (radix of 62)
        AlphaNumeric = 4,
    }
    /// Choose an alphabet which the data being transformed will be made up of.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Alphabet {
        /// Common alphabets.
        #[prost(enumeration = "FfxCommonNativeAlphabet", tag = "4")]
        CommonAlphabet(i32),
        /// This is supported by mapping these to the alphanumeric characters
        /// that the FFX mode natively supports. This happens before/after
        /// encryption/decryption.
        /// Each character listed must appear only once.
        /// Number of characters must be in the range [2, 95].
        /// This must be encoded as ASCII.
        /// The order of characters does not matter.
        /// The full list of allowed characters is:
        /// <code>0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
        /// ~`!@#$%^&*()_-+={\[}\]|\:;"'<,>.?/</code>
        #[prost(string, tag = "5")]
        CustomAlphabet(::prost::alloc::string::String),
        /// The native way to select the alphabet. Must be in the range [2, 95].
        #[prost(int32, tag = "6")]
        Radix(i32),
    }
}
/// This is a data encryption key (DEK) (as opposed to
/// a key encryption key (KEK) stored by KMS).
/// When using KMS to wrap/unwrap DEKs, be sure to set an appropriate
/// IAM policy on the KMS CryptoKey (KEK) to ensure an attacker cannot
/// unwrap the data crypto key.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CryptoKey {
    /// Sources of crypto keys.
    #[prost(oneof = "crypto_key::Source", tags = "1, 2, 3")]
    pub source: ::core::option::Option<crypto_key::Source>,
}
/// Nested message and enum types in `CryptoKey`.
pub mod crypto_key {
    /// Sources of crypto keys.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Transient crypto key
        #[prost(message, tag = "1")]
        Transient(super::TransientCryptoKey),
        /// Unwrapped crypto key
        #[prost(message, tag = "2")]
        Unwrapped(super::UnwrappedCryptoKey),
        /// Kms wrapped key
        #[prost(message, tag = "3")]
        KmsWrapped(super::KmsWrappedCryptoKey),
    }
}
/// Use this to have a random data crypto key generated.
/// It will be discarded after the request finishes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransientCryptoKey {
    /// Required. Name of the key.
    /// This is an arbitrary string used to differentiate different keys.
    /// A unique key is generated per name: two separate `TransientCryptoKey`
    /// protos share the same generated key if their names are the same.
    /// When the data crypto key is generated, this name is not used in any way
    /// (repeating the api call will result in a different key being generated).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Using raw keys is prone to security risks due to accidentally
/// leaking the key. Choose another type of key if possible.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnwrappedCryptoKey {
    /// Required. A 128/192/256 bit key.
    #[prost(bytes = "vec", tag = "1")]
    pub key: ::prost::alloc::vec::Vec<u8>,
}
/// Include to use an existing data crypto key wrapped by KMS.
/// The wrapped key must be a 128/192/256 bit key.
/// Authorization requires the following IAM permissions when sending a request
/// to perform a crypto transformation using a kms-wrapped crypto key:
/// dlp.kms.encrypt
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KmsWrappedCryptoKey {
    /// Required. The wrapped data crypto key.
    #[prost(bytes = "vec", tag = "1")]
    pub wrapped_key: ::prost::alloc::vec::Vec<u8>,
    /// Required. The resource name of the KMS CryptoKey to use for unwrapping.
    #[prost(string, tag = "2")]
    pub crypto_key_name: ::prost::alloc::string::String,
}
/// Shifts dates by random number of days, with option to be consistent for the
/// same context. See <https://cloud.google.com/dlp/docs/concepts-date-shifting>
/// to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DateShiftConfig {
    /// Required. Range of shift in days. Actual shift will be selected at random within this
    /// range (inclusive ends). Negative means shift to earlier in time. Must not
    /// be more than 365250 days (1000 years) each direction.
    ///
    /// For example, 3 means shift date to at most 3 days into the future.
    #[prost(int32, tag = "1")]
    pub upper_bound_days: i32,
    /// Required. For example, -5 means shift date to at most 5 days back in the past.
    #[prost(int32, tag = "2")]
    pub lower_bound_days: i32,
    /// Points to the field that contains the context, for example, an entity id.
    /// If set, must also set cryptoKey. If set, shift will be consistent for the
    /// given context.
    #[prost(message, optional, tag = "3")]
    pub context: ::core::option::Option<FieldId>,
    /// Method for calculating shift that takes context into consideration. If
    /// set, must also set context. Can only be applied to table items.
    #[prost(oneof = "date_shift_config::Method", tags = "4")]
    pub method: ::core::option::Option<date_shift_config::Method>,
}
/// Nested message and enum types in `DateShiftConfig`.
pub mod date_shift_config {
    /// Method for calculating shift that takes context into consideration. If
    /// set, must also set context. Can only be applied to table items.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Method {
        /// Causes the shift to be computed based on this key and the context. This
        /// results in the same shift for the same context and crypto_key. If
        /// set, must also set context. Can only be applied to table items.
        #[prost(message, tag = "4")]
        CryptoKey(super::CryptoKey),
    }
}
/// A type of transformation that will scan unstructured text and
/// apply various `PrimitiveTransformation`s to each finding, where the
/// transformation is applied to only values that were identified as a specific
/// info_type.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InfoTypeTransformations {
    /// Required. Transformation for each infoType. Cannot specify more than one
    /// for a given infoType.
    #[prost(message, repeated, tag = "1")]
    pub transformations:
        ::prost::alloc::vec::Vec<info_type_transformations::InfoTypeTransformation>,
}
/// Nested message and enum types in `InfoTypeTransformations`.
pub mod info_type_transformations {
    /// A transformation to apply to text that is identified as a specific
    /// info_type.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InfoTypeTransformation {
        /// InfoTypes to apply the transformation to. An empty list will cause
        /// this transformation to apply to all findings that correspond to
        /// infoTypes that were requested in `InspectConfig`.
        #[prost(message, repeated, tag = "1")]
        pub info_types: ::prost::alloc::vec::Vec<super::InfoType>,
        /// Required. Primitive transformation to apply to the infoType.
        #[prost(message, optional, tag = "2")]
        pub primitive_transformation: ::core::option::Option<super::PrimitiveTransformation>,
    }
}
/// The transformation to apply to the field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldTransformation {
    /// Required. Input field(s) to apply the transformation to.
    #[prost(message, repeated, tag = "1")]
    pub fields: ::prost::alloc::vec::Vec<FieldId>,
    /// Only apply the transformation if the condition evaluates to true for the
    /// given `RecordCondition`. The conditions are allowed to reference fields
    /// that are not used in the actual transformation.
    ///
    /// Example Use Cases:
    ///
    /// - Apply a different bucket transformation to an age column if the zip code
    /// column for the same record is within a specific range.
    /// - Redact a field if the date of birth field is greater than 85.
    #[prost(message, optional, tag = "3")]
    pub condition: ::core::option::Option<RecordCondition>,
    /// Transformation to apply. \[required\]
    #[prost(oneof = "field_transformation::Transformation", tags = "4, 5")]
    pub transformation: ::core::option::Option<field_transformation::Transformation>,
}
/// Nested message and enum types in `FieldTransformation`.
pub mod field_transformation {
    /// Transformation to apply. \[required\]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Transformation {
        /// Apply the transformation to the entire field.
        #[prost(message, tag = "4")]
        PrimitiveTransformation(super::PrimitiveTransformation),
        /// Treat the contents of the field as free text, and selectively
        /// transform content that matches an `InfoType`.
        #[prost(message, tag = "5")]
        InfoTypeTransformations(super::InfoTypeTransformations),
    }
}
/// A type of transformation that is applied over structured data such as a
/// table.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordTransformations {
    /// Transform the record by applying various field transformations.
    #[prost(message, repeated, tag = "1")]
    pub field_transformations: ::prost::alloc::vec::Vec<FieldTransformation>,
    /// Configuration defining which records get suppressed entirely. Records that
    /// match any suppression rule are omitted from the output.
    #[prost(message, repeated, tag = "2")]
    pub record_suppressions: ::prost::alloc::vec::Vec<RecordSuppression>,
}
/// Configuration to suppress records whose suppression conditions evaluate to
/// true.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordSuppression {
    /// A condition that when it evaluates to true will result in the record being
    /// evaluated to be suppressed from the transformed content.
    #[prost(message, optional, tag = "1")]
    pub condition: ::core::option::Option<RecordCondition>,
}
/// A condition for determining whether a transformation should be applied to
/// a field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordCondition {
    /// An expression.
    #[prost(message, optional, tag = "3")]
    pub expressions: ::core::option::Option<record_condition::Expressions>,
}
/// Nested message and enum types in `RecordCondition`.
pub mod record_condition {
    /// The field type of `value` and `field` do not need to match to be
    /// considered equal, but not all comparisons are possible.
    /// EQUAL_TO and NOT_EQUAL_TO attempt to compare even with incompatible types,
    /// but all other comparisons are invalid with incompatible types.
    /// A `value` of type:
    ///
    /// - `string` can be compared against all other types
    /// - `boolean` can only be compared against other booleans
    /// - `integer` can be compared against doubles or a string if the string value
    /// can be parsed as an integer.
    /// - `double` can be compared against integers or a string if the string can
    /// be parsed as a double.
    /// - `Timestamp` can be compared against strings in RFC 3339 date string
    /// format.
    /// - `TimeOfDay` can be compared against timestamps and strings in the format
    /// of 'HH:mm:ss'.
    ///
    /// If we fail to compare do to type mismatch, a warning will be given and
    /// the condition will evaluate to false.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Condition {
        /// Required. Field within the record this condition is evaluated against.
        #[prost(message, optional, tag = "1")]
        pub field: ::core::option::Option<super::FieldId>,
        /// Required. Operator used to compare the field or infoType to the value.
        #[prost(enumeration = "super::RelationalOperator", tag = "3")]
        pub operator: i32,
        /// Value to compare against. [Mandatory, except for `EXISTS` tests.]
        #[prost(message, optional, tag = "4")]
        pub value: ::core::option::Option<super::Value>,
    }
    /// A collection of conditions.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Conditions {
        /// A collection of conditions.
        #[prost(message, repeated, tag = "1")]
        pub conditions: ::prost::alloc::vec::Vec<Condition>,
    }
    /// An expression, consisting or an operator and conditions.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Expressions {
        /// The operator to apply to the result of conditions. Default and currently
        /// only supported value is `AND`.
        #[prost(enumeration = "expressions::LogicalOperator", tag = "1")]
        pub logical_operator: i32,
        /// Expression types.
        #[prost(oneof = "expressions::Type", tags = "3")]
        pub r#type: ::core::option::Option<expressions::Type>,
    }
    /// Nested message and enum types in `Expressions`.
    pub mod expressions {
        /// Logical operators for conditional checks.
        #[derive(
            Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
        )]
        #[repr(i32)]
        pub enum LogicalOperator {
            /// Unused
            Unspecified = 0,
            /// Conditional AND
            And = 1,
        }
        /// Expression types.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// Conditions to apply to the expression.
            #[prost(message, tag = "3")]
            Conditions(super::Conditions),
        }
    }
}
/// Overview of the modifications that occurred.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransformationOverview {
    /// Total size in bytes that were transformed in some way.
    #[prost(int64, tag = "2")]
    pub transformed_bytes: i64,
    /// Transformations applied to the dataset.
    #[prost(message, repeated, tag = "3")]
    pub transformation_summaries: ::prost::alloc::vec::Vec<TransformationSummary>,
}
/// Summary of a single transformation.
/// Only one of 'transformation', 'field_transformation', or 'record_suppress'
/// will be set.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransformationSummary {
    /// Set if the transformation was limited to a specific InfoType.
    #[prost(message, optional, tag = "1")]
    pub info_type: ::core::option::Option<InfoType>,
    /// Set if the transformation was limited to a specific FieldId.
    #[prost(message, optional, tag = "2")]
    pub field: ::core::option::Option<FieldId>,
    /// The specific transformation these stats apply to.
    #[prost(message, optional, tag = "3")]
    pub transformation: ::core::option::Option<PrimitiveTransformation>,
    /// The field transformation that was applied.
    /// If multiple field transformations are requested for a single field,
    /// this list will contain all of them; otherwise, only one is supplied.
    #[prost(message, repeated, tag = "5")]
    pub field_transformations: ::prost::alloc::vec::Vec<FieldTransformation>,
    /// The specific suppression option these stats apply to.
    #[prost(message, optional, tag = "6")]
    pub record_suppress: ::core::option::Option<RecordSuppression>,
    /// Collection of all transformations that took place or had an error.
    #[prost(message, repeated, tag = "4")]
    pub results: ::prost::alloc::vec::Vec<transformation_summary::SummaryResult>,
    /// Total size in bytes that were transformed in some way.
    #[prost(int64, tag = "7")]
    pub transformed_bytes: i64,
}
/// Nested message and enum types in `TransformationSummary`.
pub mod transformation_summary {
    /// A collection that informs the user the number of times a particular
    /// `TransformationResultCode` and error details occurred.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SummaryResult {
        /// Number of transformations counted by this result.
        #[prost(int64, tag = "1")]
        pub count: i64,
        /// Outcome of the transformation.
        #[prost(enumeration = "TransformationResultCode", tag = "2")]
        pub code: i32,
        /// A place for warnings or errors to show up if a transformation didn't
        /// work as expected.
        #[prost(string, tag = "3")]
        pub details: ::prost::alloc::string::String,
    }
    /// Possible outcomes of transformations.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum TransformationResultCode {
        /// Unused
        Unspecified = 0,
        /// Transformation completed without an error.
        Success = 1,
        /// Transformation had an error.
        Error = 2,
    }
}
/// Schedule for triggeredJobs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schedule {
    #[prost(oneof = "schedule::Option", tags = "1")]
    pub option: ::core::option::Option<schedule::Option>,
}
/// Nested message and enum types in `Schedule`.
pub mod schedule {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// With this option a job is started a regular periodic basis. For
        /// example: every day (86400 seconds).
        ///
        /// A scheduled start time will be skipped if the previous
        /// execution has not ended when its scheduled time occurs.
        ///
        /// This value must be set to a time duration greater than or equal
        /// to 1 day and can be no longer than 60 days.
        #[prost(message, tag = "1")]
        RecurrencePeriodDuration(::prost_types::Duration),
    }
}
/// Job trigger option for hybrid jobs. Jobs must be manually created
/// and finished.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Manual {}
/// The inspectTemplate contains a configuration (set of types of sensitive data
/// to be detected) to be used anywhere you otherwise would normally specify
/// InspectConfig. See <https://cloud.google.com/dlp/docs/concepts-templates>
/// to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectTemplate {
    /// Output only. The template name.
    ///
    /// The template will have one of the following formats:
    /// `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
    /// `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Display name (max 256 chars).
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Short description (max 256 chars).
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The creation timestamp of an inspectTemplate.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last update timestamp of an inspectTemplate.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The core content of the template. Configuration of the scanning process.
    #[prost(message, optional, tag = "6")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
}
/// DeidentifyTemplates contains instructions on how to de-identify content.
/// See <https://cloud.google.com/dlp/docs/concepts-templates> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeidentifyTemplate {
    /// Output only. The template name.
    ///
    /// The template will have one of the following formats:
    /// `projects/PROJECT_ID/deidentifyTemplates/TEMPLATE_ID` OR
    /// `organizations/ORGANIZATION_ID/deidentifyTemplates/TEMPLATE_ID`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Display name (max 256 chars).
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Short description (max 256 chars).
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The creation timestamp of an inspectTemplate.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last update timestamp of an inspectTemplate.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// ///////////// // The core content of the template  // ///////////////
    #[prost(message, optional, tag = "6")]
    pub deidentify_config: ::core::option::Option<DeidentifyConfig>,
}
/// Details information about an error encountered during job execution or
/// the results of an unsuccessful activation of the JobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Error {
    /// Detailed error codes and messages.
    #[prost(message, optional, tag = "1")]
    pub details: ::core::option::Option<super::super::super::rpc::Status>,
    /// The times the error occurred.
    #[prost(message, repeated, tag = "2")]
    pub timestamps: ::prost::alloc::vec::Vec<::prost_types::Timestamp>,
}
/// Contains a configuration to make dlp api calls on a repeating basis.
/// See <https://cloud.google.com/dlp/docs/concepts-job-triggers> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobTrigger {
    /// Unique resource name for the triggeredJob, assigned by the service when the
    /// triggeredJob is created, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Display name (max 100 chars)
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// User provided description (max 256 chars)
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// A list of triggers which will be OR'ed together. Only one in the list
    /// needs to trigger for a job to be started. The list may contain only
    /// a single Schedule trigger and must have at least one object.
    #[prost(message, repeated, tag = "5")]
    pub triggers: ::prost::alloc::vec::Vec<job_trigger::Trigger>,
    /// Output only. A stream of errors encountered when the trigger was activated. Repeated
    /// errors may result in the JobTrigger automatically being paused.
    /// Will return the last 100 errors. Whenever the JobTrigger is modified
    /// this list will be cleared.
    #[prost(message, repeated, tag = "6")]
    pub errors: ::prost::alloc::vec::Vec<Error>,
    /// Output only. The creation timestamp of a triggeredJob.
    #[prost(message, optional, tag = "7")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The last update timestamp of a triggeredJob.
    #[prost(message, optional, tag = "8")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp of the last time this trigger executed.
    #[prost(message, optional, tag = "9")]
    pub last_run_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Required. A status for this trigger.
    #[prost(enumeration = "job_trigger::Status", tag = "10")]
    pub status: i32,
    /// The configuration details for the specific type of job to run.
    #[prost(oneof = "job_trigger::Job", tags = "4")]
    pub job: ::core::option::Option<job_trigger::Job>,
}
/// Nested message and enum types in `JobTrigger`.
pub mod job_trigger {
    /// What event needs to occur for a new job to be started.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Trigger {
        #[prost(oneof = "trigger::Trigger", tags = "1, 2")]
        pub trigger: ::core::option::Option<trigger::Trigger>,
    }
    /// Nested message and enum types in `Trigger`.
    pub mod trigger {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Trigger {
            /// Create a job on a repeating basis based on the elapse of time.
            #[prost(message, tag = "1")]
            Schedule(super::super::Schedule),
            /// For use with hybrid jobs. Jobs must be manually created and finished.
            /// Early access feature is in a pre-release state and might change or have
            /// limited support. For more information, see
            /// <https://cloud.google.com/products#product-launch-stages.>
            #[prost(message, tag = "2")]
            Manual(super::super::Manual),
        }
    }
    /// Whether the trigger is currently active. If PAUSED or CANCELLED, no jobs
    /// will be created with this configuration. The service may automatically
    /// pause triggers experiencing frequent errors. To restart a job, set the
    /// status to HEALTHY after correcting user errors.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Status {
        /// Unused.
        Unspecified = 0,
        /// Trigger is healthy.
        Healthy = 1,
        /// Trigger is temporarily paused.
        Paused = 2,
        /// Trigger is cancelled and can not be resumed.
        Cancelled = 3,
    }
    /// The configuration details for the specific type of job to run.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Job {
        /// For inspect jobs, a snapshot of the configuration.
        #[prost(message, tag = "4")]
        InspectJob(super::InspectJobConfig),
    }
}
/// A task to execute on the completion of a job.
/// See <https://cloud.google.com/dlp/docs/concepts-actions> to learn more.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Action {
    #[prost(oneof = "action::Action", tags = "1, 2, 3, 5, 8, 9")]
    pub action: ::core::option::Option<action::Action>,
}
/// Nested message and enum types in `Action`.
pub mod action {
    /// If set, the detailed findings will be persisted to the specified
    /// OutputStorageConfig. Only a single instance of this action can be
    /// specified.
    /// Compatible with: Inspect, Risk
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SaveFindings {
        /// Location to store findings outside of DLP.
        #[prost(message, optional, tag = "1")]
        pub output_config: ::core::option::Option<super::OutputStorageConfig>,
    }
    /// Publish a message into given Pub/Sub topic when DlpJob has completed. The
    /// message contains a single field, `DlpJobName`, which is equal to the
    /// finished job's
    /// \[`DlpJob.name`\](<https://cloud.google.com/dlp/docs/reference/rest/v2/projects.dlpJobs#DlpJob>).
    /// Compatible with: Inspect, Risk
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PublishToPubSub {
        /// Cloud Pub/Sub topic to send notifications to. The topic must have given
        /// publishing access rights to the DLP API service account executing
        /// the long running DlpJob sending the notifications.
        /// Format is projects/{project}/topics/{topic}.
        #[prost(string, tag = "1")]
        pub topic: ::prost::alloc::string::String,
    }
    /// Publish the result summary of a DlpJob to the Cloud Security
    /// Command Center (CSCC Alpha).
    /// This action is only available for projects which are parts of
    /// an organization and whitelisted for the alpha Cloud Security Command
    /// Center.
    /// The action will publish count of finding instances and their info types.
    /// The summary of findings will be persisted in CSCC and are governed by CSCC
    /// service-specific policy, see <https://cloud.google.com/terms/service-terms>
    /// Only a single instance of this action can be specified.
    /// Compatible with: Inspect
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PublishSummaryToCscc {}
    /// Publish findings of a DlpJob to Cloud Data Catalog. Labels summarizing the
    /// results of the DlpJob will be applied to the entry for the resource scanned
    /// in Cloud Data Catalog. Any labels previously written by another DlpJob will
    /// be deleted. InfoType naming patterns are strictly enforced when using this
    /// feature. Note that the findings will be persisted in Cloud Data Catalog
    /// storage and are governed by Data Catalog service-specific policy, see
    /// <https://cloud.google.com/terms/service-terms>
    /// Only a single instance of this action can be specified and only allowed if
    /// all resources being scanned are BigQuery tables.
    /// Compatible with: Inspect
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PublishFindingsToCloudDataCatalog {}
    /// Enable email notification to project owners and editors on jobs's
    /// completion/failure.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct JobNotificationEmails {}
    /// Enable Stackdriver metric dlp.googleapis.com/finding_count. This
    /// will publish a metric to stack driver on each infotype requested and
    /// how many findings were found for it. CustomDetectors will be bucketed
    /// as 'Custom' under the Stackdriver label 'info_type'.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PublishToStackdriver {}
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        /// Save resulting findings in a provided location.
        #[prost(message, tag = "1")]
        SaveFindings(SaveFindings),
        /// Publish a notification to a pubsub topic.
        #[prost(message, tag = "2")]
        PubSub(PublishToPubSub),
        /// Publish summary to Cloud Security Command Center (Alpha).
        #[prost(message, tag = "3")]
        PublishSummaryToCscc(PublishSummaryToCscc),
        /// Publish findings to Cloud Datahub.
        #[prost(message, tag = "5")]
        PublishFindingsToCloudDataCatalog(PublishFindingsToCloudDataCatalog),
        /// Enable email notification for project owners and editors on job's
        /// completion/failure.
        #[prost(message, tag = "8")]
        JobNotificationEmails(JobNotificationEmails),
        /// Enable Stackdriver metric dlp.googleapis.com/finding_count.
        #[prost(message, tag = "9")]
        PublishToStackdriver(PublishToStackdriver),
    }
}
/// Request message for CreateInspectTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateInspectTemplateRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The InspectTemplate to create.
    #[prost(message, optional, tag = "2")]
    pub inspect_template: ::core::option::Option<InspectTemplate>,
    /// The template id can contain uppercase and lowercase letters,
    /// numbers, and hyphens; that is, it must match the regular
    /// expression: `\[a-zA-Z\d-_\]+`. The maximum length is 100
    /// characters. Can be empty to allow the system to generate one.
    #[prost(string, tag = "3")]
    pub template_id: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "4")]
    pub location_id: ::prost::alloc::string::String,
}
/// Request message for UpdateInspectTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateInspectTemplateRequest {
    /// Required. Resource name of organization and inspectTemplate to be updated, for
    /// example `organizations/433245324/inspectTemplates/432452342` or
    /// projects/project-id/inspectTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// New InspectTemplate value.
    #[prost(message, optional, tag = "2")]
    pub inspect_template: ::core::option::Option<InspectTemplate>,
    /// Mask to control which fields get updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for GetInspectTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInspectTemplateRequest {
    /// Required. Resource name of the organization and inspectTemplate to be read, for
    /// example `organizations/433245324/inspectTemplates/432452342` or
    /// projects/project-id/inspectTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for ListInspectTemplates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInspectTemplatesRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Page token to continue retrieval. Comes from previous call
    /// to `ListInspectTemplates`.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    /// Size of the page, can be limited by server. If zero server returns
    /// a page of max size 100.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Comma separated list of fields to order by,
    /// followed by `asc` or `desc` postfix. This list is case-insensitive,
    /// default sorting order is ascending, redundant space characters are
    /// insignificant.
    ///
    /// Example: `name asc,update_time, create_time desc`
    ///
    /// Supported fields are:
    ///
    /// - `create_time`: corresponds to time the template was created.
    /// - `update_time`: corresponds to time the template was last updated.
    /// - `name`: corresponds to template's name.
    /// - `display_name`: corresponds to template's display name.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "5")]
    pub location_id: ::prost::alloc::string::String,
}
/// Response message for ListInspectTemplates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInspectTemplatesResponse {
    /// List of inspectTemplates, up to page_size in ListInspectTemplatesRequest.
    #[prost(message, repeated, tag = "1")]
    pub inspect_templates: ::prost::alloc::vec::Vec<InspectTemplate>,
    /// If the next page is available then the next page token to be used
    /// in following ListInspectTemplates request.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for DeleteInspectTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInspectTemplateRequest {
    /// Required. Resource name of the organization and inspectTemplate to be deleted, for
    /// example `organizations/433245324/inspectTemplates/432452342` or
    /// projects/project-id/inspectTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for CreateJobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateJobTriggerRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The JobTrigger to create.
    #[prost(message, optional, tag = "2")]
    pub job_trigger: ::core::option::Option<JobTrigger>,
    /// The trigger id can contain uppercase and lowercase letters,
    /// numbers, and hyphens; that is, it must match the regular
    /// expression: `\[a-zA-Z\d-_\]+`. The maximum length is 100
    /// characters. Can be empty to allow the system to generate one.
    #[prost(string, tag = "3")]
    pub trigger_id: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "4")]
    pub location_id: ::prost::alloc::string::String,
}
/// Request message for ActivateJobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateJobTriggerRequest {
    /// Required. Resource name of the trigger to activate, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for UpdateJobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateJobTriggerRequest {
    /// Required. Resource name of the project and the triggeredJob, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// New JobTrigger value.
    #[prost(message, optional, tag = "2")]
    pub job_trigger: ::core::option::Option<JobTrigger>,
    /// Mask to control which fields get updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for GetJobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetJobTriggerRequest {
    /// Required. Resource name of the project and the triggeredJob, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for CreateDlpJobRequest. Used to initiate long running
/// jobs such as calculating risk metrics or inspecting Google Cloud
/// Storage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDlpJobRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The job id can contain uppercase and lowercase letters,
    /// numbers, and hyphens; that is, it must match the regular
    /// expression: `\[a-zA-Z\d-_\]+`. The maximum length is 100
    /// characters. Can be empty to allow the system to generate one.
    #[prost(string, tag = "4")]
    pub job_id: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "5")]
    pub location_id: ::prost::alloc::string::String,
    /// The configuration details for the specific type of job to run.
    #[prost(oneof = "create_dlp_job_request::Job", tags = "2, 3")]
    pub job: ::core::option::Option<create_dlp_job_request::Job>,
}
/// Nested message and enum types in `CreateDlpJobRequest`.
pub mod create_dlp_job_request {
    /// The configuration details for the specific type of job to run.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Job {
        /// Set to control what and how to inspect.
        #[prost(message, tag = "2")]
        InspectJob(super::InspectJobConfig),
        /// Set to choose what metric to calculate.
        #[prost(message, tag = "3")]
        RiskJob(super::RiskAnalysisJobConfig),
    }
}
/// Request message for ListJobTriggers.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobTriggersRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Page token to continue retrieval. Comes from previous call
    /// to ListJobTriggers. `order_by` field must not
    /// change for subsequent calls.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    /// Size of the page, can be limited by a server.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Comma separated list of triggeredJob fields to order by,
    /// followed by `asc` or `desc` postfix. This list is case-insensitive,
    /// default sorting order is ascending, redundant space characters are
    /// insignificant.
    ///
    /// Example: `name asc,update_time, create_time desc`
    ///
    /// Supported fields are:
    ///
    /// - `create_time`: corresponds to time the JobTrigger was created.
    /// - `update_time`: corresponds to time the JobTrigger was last updated.
    /// - `last_run_time`: corresponds to the last time the JobTrigger ran.
    /// - `name`: corresponds to JobTrigger's name.
    /// - `display_name`: corresponds to JobTrigger's display name.
    /// - `status`: corresponds to JobTrigger's status.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Allows filtering.
    ///
    /// Supported syntax:
    ///
    /// * Filter expressions are made up of one or more restrictions.
    /// * Restrictions can be combined by `AND` or `OR` logical operators. A
    /// sequence of restrictions implicitly uses `AND`.
    /// * A restriction has the form of `{field} {operator} {value}`.
    /// * Supported fields/values for inspect jobs:
    ///     - `status` - HEALTHY|PAUSED|CANCELLED
    ///     - `inspected_storage` - DATASTORE|CLOUD_STORAGE|BIGQUERY
    ///     - 'last_run_time` - RFC 3339 formatted timestamp, surrounded by
    ///     quotation marks. Nanoseconds are ignored.
    ///     - 'error_count' - Number of errors that have occurred while running.
    /// * The operator must be `=` or `!=` for status and inspected_storage.
    ///
    /// Examples:
    ///
    /// * inspected_storage = cloud_storage AND status = HEALTHY
    /// * inspected_storage = cloud_storage OR inspected_storage = bigquery
    /// * inspected_storage = cloud_storage AND (state = PAUSED OR state = HEALTHY)
    /// * last_run_time > \"2017-12-12T00:00:00+00:00\"
    ///
    /// The length of this field should be no more than 500 characters.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "7")]
    pub location_id: ::prost::alloc::string::String,
}
/// Response message for ListJobTriggers.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobTriggersResponse {
    /// List of triggeredJobs, up to page_size in ListJobTriggersRequest.
    #[prost(message, repeated, tag = "1")]
    pub job_triggers: ::prost::alloc::vec::Vec<JobTrigger>,
    /// If the next page is available then the next page token to be used
    /// in following ListJobTriggers request.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for DeleteJobTrigger.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteJobTriggerRequest {
    /// Required. Resource name of the project and the triggeredJob, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Controls what and how to inspect for findings.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InspectJobConfig {
    /// The data to scan.
    #[prost(message, optional, tag = "1")]
    pub storage_config: ::core::option::Option<StorageConfig>,
    /// How and what to scan for.
    #[prost(message, optional, tag = "2")]
    pub inspect_config: ::core::option::Option<InspectConfig>,
    /// If provided, will be used as the default for all values in InspectConfig.
    /// `inspect_config` will be merged into the values persisted as part of the
    /// template.
    #[prost(string, tag = "3")]
    pub inspect_template_name: ::prost::alloc::string::String,
    /// Actions to execute at the completion of the job.
    #[prost(message, repeated, tag = "4")]
    pub actions: ::prost::alloc::vec::Vec<Action>,
}
/// Combines all of the information about a DLP job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DlpJob {
    /// The server-assigned name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The type of job.
    #[prost(enumeration = "DlpJobType", tag = "2")]
    pub r#type: i32,
    /// State of a job.
    #[prost(enumeration = "dlp_job::JobState", tag = "3")]
    pub state: i32,
    /// Time when the job was created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the job started.
    #[prost(message, optional, tag = "7")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the job finished.
    #[prost(message, optional, tag = "8")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// If created by a job trigger, the resource name of the trigger that
    /// instantiated the job.
    #[prost(string, tag = "10")]
    pub job_trigger_name: ::prost::alloc::string::String,
    /// A stream of errors encountered running the job.
    #[prost(message, repeated, tag = "11")]
    pub errors: ::prost::alloc::vec::Vec<Error>,
    #[prost(oneof = "dlp_job::Details", tags = "4, 5")]
    pub details: ::core::option::Option<dlp_job::Details>,
}
/// Nested message and enum types in `DlpJob`.
pub mod dlp_job {
    /// Possible states of a job. New items may be added.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum JobState {
        /// Unused.
        Unspecified = 0,
        /// The job has not yet started.
        Pending = 1,
        /// The job is currently running. Once a job has finished it will transition
        /// to FAILED or DONE.
        Running = 2,
        /// The job is no longer running.
        Done = 3,
        /// The job was canceled before it could complete.
        Canceled = 4,
        /// The job had an error and did not complete.
        Failed = 5,
        /// The job is currently accepting findings via hybridInspect.
        /// A hybrid job in ACTIVE state may continue to have findings added to it
        /// through calling of hybridInspect. After the job has finished no more
        /// calls to hybridInspect may be made. ACTIVE jobs can transition to DONE.
        Active = 6,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Details {
        /// Results from analyzing risk of a data source.
        #[prost(message, tag = "4")]
        RiskDetails(super::AnalyzeDataSourceRiskDetails),
        /// Results from inspecting a data source.
        #[prost(message, tag = "5")]
        InspectDetails(super::InspectDataSourceDetails),
    }
}
/// The request message for \[DlpJobs.GetDlpJob][\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDlpJobRequest {
    /// Required. The name of the DlpJob resource.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for listing DLP jobs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDlpJobsRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on whether you have [specified a
    /// processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "4")]
    pub parent: ::prost::alloc::string::String,
    /// Allows filtering.
    ///
    /// Supported syntax:
    ///
    /// * Filter expressions are made up of one or more restrictions.
    /// * Restrictions can be combined by `AND` or `OR` logical operators. A
    /// sequence of restrictions implicitly uses `AND`.
    /// * A restriction has the form of `{field} {operator} {value}`.
    /// * Supported fields/values for inspect jobs:
    ///     - `state` - PENDING|RUNNING|CANCELED|FINISHED|FAILED
    ///     - `inspected_storage` - DATASTORE|CLOUD_STORAGE|BIGQUERY
    ///     - `trigger_name` - The resource name of the trigger that created job.
    ///     - 'end_time` - Corresponds to time the job finished.
    ///     - 'start_time` - Corresponds to time the job finished.
    /// * Supported fields for risk analysis jobs:
    ///     - `state` - RUNNING|CANCELED|FINISHED|FAILED
    ///     - 'end_time` - Corresponds to time the job finished.
    ///     - 'start_time` - Corresponds to time the job finished.
    /// * The operator must be `=` or `!=`.
    ///
    /// Examples:
    ///
    /// * inspected_storage = cloud_storage AND state = done
    /// * inspected_storage = cloud_storage OR inspected_storage = bigquery
    /// * inspected_storage = cloud_storage AND (state = done OR state = canceled)
    /// * end_time > \"2017-12-12T00:00:00+00:00\"
    ///
    /// The length of this field should be no more than 500 characters.
    #[prost(string, tag = "1")]
    pub filter: ::prost::alloc::string::String,
    /// The standard list page size.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The standard list page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The type of job. Defaults to `DlpJobType.INSPECT`
    #[prost(enumeration = "DlpJobType", tag = "5")]
    pub r#type: i32,
    /// Comma separated list of fields to order by,
    /// followed by `asc` or `desc` postfix. This list is case-insensitive,
    /// default sorting order is ascending, redundant space characters are
    /// insignificant.
    ///
    /// Example: `name asc, end_time asc, create_time desc`
    ///
    /// Supported fields are:
    ///
    /// - `create_time`: corresponds to time the job was created.
    /// - `end_time`: corresponds to time the job ended.
    /// - `name`: corresponds to job's name.
    /// - `state`: corresponds to `state`
    #[prost(string, tag = "6")]
    pub order_by: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "7")]
    pub location_id: ::prost::alloc::string::String,
}
/// The response message for listing DLP jobs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDlpJobsResponse {
    /// A list of DlpJobs that matches the specified filter in the request.
    #[prost(message, repeated, tag = "1")]
    pub jobs: ::prost::alloc::vec::Vec<DlpJob>,
    /// The standard List next-page token.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for canceling a DLP job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelDlpJobRequest {
    /// Required. The name of the DlpJob resource to be cancelled.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for finishing a DLP hybrid job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinishDlpJobRequest {
    /// Required. The name of the DlpJob resource to be cancelled.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for deleting a DLP job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDlpJobRequest {
    /// Required. The name of the DlpJob resource to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for CreateDeidentifyTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDeidentifyTemplateRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The DeidentifyTemplate to create.
    #[prost(message, optional, tag = "2")]
    pub deidentify_template: ::core::option::Option<DeidentifyTemplate>,
    /// The template id can contain uppercase and lowercase letters,
    /// numbers, and hyphens; that is, it must match the regular
    /// expression: `\[a-zA-Z\d-_\]+`. The maximum length is 100
    /// characters. Can be empty to allow the system to generate one.
    #[prost(string, tag = "3")]
    pub template_id: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "4")]
    pub location_id: ::prost::alloc::string::String,
}
/// Request message for UpdateDeidentifyTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDeidentifyTemplateRequest {
    /// Required. Resource name of organization and deidentify template to be updated, for
    /// example `organizations/433245324/deidentifyTemplates/432452342` or
    /// projects/project-id/deidentifyTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// New DeidentifyTemplate value.
    #[prost(message, optional, tag = "2")]
    pub deidentify_template: ::core::option::Option<DeidentifyTemplate>,
    /// Mask to control which fields get updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for GetDeidentifyTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeidentifyTemplateRequest {
    /// Required. Resource name of the organization and deidentify template to be read, for
    /// example `organizations/433245324/deidentifyTemplates/432452342` or
    /// projects/project-id/deidentifyTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for ListDeidentifyTemplates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeidentifyTemplatesRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Page token to continue retrieval. Comes from previous call
    /// to `ListDeidentifyTemplates`.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    /// Size of the page, can be limited by server. If zero server returns
    /// a page of max size 100.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Comma separated list of fields to order by,
    /// followed by `asc` or `desc` postfix. This list is case-insensitive,
    /// default sorting order is ascending, redundant space characters are
    /// insignificant.
    ///
    /// Example: `name asc,update_time, create_time desc`
    ///
    /// Supported fields are:
    ///
    /// - `create_time`: corresponds to time the template was created.
    /// - `update_time`: corresponds to time the template was last updated.
    /// - `name`: corresponds to template's name.
    /// - `display_name`: corresponds to template's display name.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "5")]
    pub location_id: ::prost::alloc::string::String,
}
/// Response message for ListDeidentifyTemplates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeidentifyTemplatesResponse {
    /// List of deidentify templates, up to page_size in
    /// ListDeidentifyTemplatesRequest.
    #[prost(message, repeated, tag = "1")]
    pub deidentify_templates: ::prost::alloc::vec::Vec<DeidentifyTemplate>,
    /// If the next page is available then the next page token to be used
    /// in following ListDeidentifyTemplates request.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for DeleteDeidentifyTemplate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDeidentifyTemplateRequest {
    /// Required. Resource name of the organization and deidentify template to be deleted,
    /// for example `organizations/433245324/deidentifyTemplates/432452342` or
    /// projects/project-id/deidentifyTemplates/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Configuration for a custom dictionary created from a data source of any size
/// up to the maximum size defined in the
/// \[limits\](<https://cloud.google.com/dlp/limits>) page. The artifacts of
/// dictionary creation are stored in the specified Google Cloud Storage
/// location. Consider using `CustomInfoType.Dictionary` for smaller dictionaries
/// that satisfy the size requirements.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LargeCustomDictionaryConfig {
    /// Location to store dictionary artifacts in Google Cloud Storage. These files
    /// will only be accessible by project owners and the DLP API. If any of these
    /// artifacts are modified, the dictionary is considered invalid and can no
    /// longer be used.
    #[prost(message, optional, tag = "1")]
    pub output_path: ::core::option::Option<CloudStoragePath>,
    #[prost(oneof = "large_custom_dictionary_config::Source", tags = "2, 3")]
    pub source: ::core::option::Option<large_custom_dictionary_config::Source>,
}
/// Nested message and enum types in `LargeCustomDictionaryConfig`.
pub mod large_custom_dictionary_config {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Set of files containing newline-delimited lists of dictionary phrases.
        #[prost(message, tag = "2")]
        CloudStorageFileSet(super::CloudStorageFileSet),
        /// Field in a BigQuery table where each cell represents a dictionary phrase.
        #[prost(message, tag = "3")]
        BigQueryField(super::BigQueryField),
    }
}
/// Summary statistics of a custom dictionary.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LargeCustomDictionaryStats {
    /// Approximate number of distinct phrases in the dictionary.
    #[prost(int64, tag = "1")]
    pub approx_num_phrases: i64,
}
/// Configuration for stored infoTypes. All fields and subfield are provided
/// by the user. For more information, see
/// <https://cloud.google.com/dlp/docs/creating-custom-infotypes.>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StoredInfoTypeConfig {
    /// Display name of the StoredInfoType (max 256 characters).
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// Description of the StoredInfoType (max 256 characters).
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Stored infotype types.
    #[prost(oneof = "stored_info_type_config::Type", tags = "3, 4, 5")]
    pub r#type: ::core::option::Option<stored_info_type_config::Type>,
}
/// Nested message and enum types in `StoredInfoTypeConfig`.
pub mod stored_info_type_config {
    /// Stored infotype types.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// StoredInfoType where findings are defined by a dictionary of phrases.
        #[prost(message, tag = "3")]
        LargeCustomDictionary(super::LargeCustomDictionaryConfig),
        /// Store dictionary-based CustomInfoType.
        #[prost(message, tag = "4")]
        Dictionary(super::custom_info_type::Dictionary),
        /// Store regular expression-based StoredInfoType.
        #[prost(message, tag = "5")]
        Regex(super::custom_info_type::Regex),
    }
}
/// Statistics for a StoredInfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StoredInfoTypeStats {
    /// Stat types
    #[prost(oneof = "stored_info_type_stats::Type", tags = "1")]
    pub r#type: ::core::option::Option<stored_info_type_stats::Type>,
}
/// Nested message and enum types in `StoredInfoTypeStats`.
pub mod stored_info_type_stats {
    /// Stat types
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// StoredInfoType where findings are defined by a dictionary of phrases.
        #[prost(message, tag = "1")]
        LargeCustomDictionary(super::LargeCustomDictionaryStats),
    }
}
/// Version of a StoredInfoType, including the configuration used to build it,
/// create timestamp, and current state.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StoredInfoTypeVersion {
    /// StoredInfoType configuration.
    #[prost(message, optional, tag = "1")]
    pub config: ::core::option::Option<StoredInfoTypeConfig>,
    /// Create timestamp of the version. Read-only, determined by the system
    /// when the version is created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Stored info type version state. Read-only, updated by the system
    /// during dictionary creation.
    #[prost(enumeration = "StoredInfoTypeState", tag = "3")]
    pub state: i32,
    /// Errors that occurred when creating this storedInfoType version, or
    /// anomalies detected in the storedInfoType data that render it unusable. Only
    /// the five most recent errors will be displayed, with the most recent error
    /// appearing first.
    ///
    /// For example, some of the data for stored custom dictionaries is put in
    /// the user's Google Cloud Storage bucket, and if this data is modified or
    /// deleted by the user or another system, the dictionary becomes invalid.
    ///
    /// If any errors occur, fix the problem indicated by the error message and
    /// use the UpdateStoredInfoType API method to create another version of the
    /// storedInfoType to continue using it, reusing the same `config` if it was
    /// not the source of the error.
    #[prost(message, repeated, tag = "4")]
    pub errors: ::prost::alloc::vec::Vec<Error>,
    /// Statistics about this storedInfoType version.
    #[prost(message, optional, tag = "5")]
    pub stats: ::core::option::Option<StoredInfoTypeStats>,
}
/// StoredInfoType resource message that contains information about the current
/// version and any pending updates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StoredInfoType {
    /// Resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Current version of the stored info type.
    #[prost(message, optional, tag = "2")]
    pub current_version: ::core::option::Option<StoredInfoTypeVersion>,
    /// Pending versions of the stored info type. Empty if no versions are
    /// pending.
    #[prost(message, repeated, tag = "3")]
    pub pending_versions: ::prost::alloc::vec::Vec<StoredInfoTypeVersion>,
}
/// Request message for CreateStoredInfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateStoredInfoTypeRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Configuration of the storedInfoType to create.
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<StoredInfoTypeConfig>,
    /// The storedInfoType ID can contain uppercase and lowercase letters,
    /// numbers, and hyphens; that is, it must match the regular
    /// expression: `\[a-zA-Z\d-_\]+`. The maximum length is 100
    /// characters. Can be empty to allow the system to generate one.
    #[prost(string, tag = "3")]
    pub stored_info_type_id: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "4")]
    pub location_id: ::prost::alloc::string::String,
}
/// Request message for UpdateStoredInfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStoredInfoTypeRequest {
    /// Required. Resource name of organization and storedInfoType to be updated, for
    /// example `organizations/433245324/storedInfoTypes/432452342` or
    /// projects/project-id/storedInfoTypes/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Updated configuration for the storedInfoType. If not provided, a new
    /// version of the storedInfoType will be created with the existing
    /// configuration.
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<StoredInfoTypeConfig>,
    /// Mask to control which fields get updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for GetStoredInfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetStoredInfoTypeRequest {
    /// Required. Resource name of the organization and storedInfoType to be read, for
    /// example `organizations/433245324/storedInfoTypes/432452342` or
    /// projects/project-id/storedInfoTypes/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for ListStoredInfoTypes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStoredInfoTypesRequest {
    /// Required. Parent resource name.
    ///
    /// The format of this value varies depending on the scope of the request
    /// (project or organization) and whether you have [specified a processing
    /// location](<https://cloud.google.com/dlp/docs/specifying-location>):
    ///
    /// + Projects scope, location specified:<br/>
    ///   `projects/`<var>PROJECT_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Projects scope, no location specified (defaults to global):<br/>
    ///   `projects/`<var>PROJECT_ID</var>
    /// + Organizations scope, location specified:<br/>
    ///   `organizations/`<var>ORG_ID</var>`/locations/`<var>LOCATION_ID</var>
    /// + Organizations scope, no location specified (defaults to global):<br/>
    ///   `organizations/`<var>ORG_ID</var>
    ///
    /// The following example `parent` string specifies a parent project with the
    /// identifier `example-project`, and specifies the `europe-west3` location
    /// for processing data:
    ///
    ///     parent=projects/example-project/locations/europe-west3
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Page token to continue retrieval. Comes from previous call
    /// to `ListStoredInfoTypes`.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    /// Size of the page, can be limited by server. If zero server returns
    /// a page of max size 100.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Comma separated list of fields to order by,
    /// followed by `asc` or `desc` postfix. This list is case-insensitive,
    /// default sorting order is ascending, redundant space characters are
    /// insignificant.
    ///
    /// Example: `name asc, display_name, create_time desc`
    ///
    /// Supported fields are:
    ///
    /// - `create_time`: corresponds to time the most recent version of the
    /// resource was created.
    /// - `state`: corresponds to the state of the resource.
    /// - `name`: corresponds to resource name.
    /// - `display_name`: corresponds to info type's display name.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
    /// Deprecated. This field has no effect.
    #[prost(string, tag = "5")]
    pub location_id: ::prost::alloc::string::String,
}
/// Response message for ListStoredInfoTypes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStoredInfoTypesResponse {
    /// List of storedInfoTypes, up to page_size in ListStoredInfoTypesRequest.
    #[prost(message, repeated, tag = "1")]
    pub stored_info_types: ::prost::alloc::vec::Vec<StoredInfoType>,
    /// If the next page is available then the next page token to be used
    /// in following ListStoredInfoTypes request.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for DeleteStoredInfoType.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteStoredInfoTypeRequest {
    /// Required. Resource name of the organization and storedInfoType to be deleted, for
    /// example `organizations/433245324/storedInfoTypes/432452342` or
    /// projects/project-id/storedInfoTypes/432452342.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request to search for potentially sensitive info in a custom location.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridInspectJobTriggerRequest {
    /// Required. Resource name of the trigger to execute a hybrid inspect on, for example
    /// `projects/dlp-test-project/jobTriggers/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The item to inspect.
    #[prost(message, optional, tag = "3")]
    pub hybrid_item: ::core::option::Option<HybridContentItem>,
}
/// Request to search for potentially sensitive info in a custom location.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridInspectDlpJobRequest {
    /// Required. Resource name of the job to execute a hybrid inspect on, for example
    /// `projects/dlp-test-project/dlpJob/53234423`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The item to inspect.
    #[prost(message, optional, tag = "3")]
    pub hybrid_item: ::core::option::Option<HybridContentItem>,
}
/// An individual hybrid item to inspect. Will be stored temporarily during
/// processing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridContentItem {
    /// The item to inspect.
    #[prost(message, optional, tag = "1")]
    pub item: ::core::option::Option<ContentItem>,
    /// Supplementary information that will be added to each finding.
    #[prost(message, optional, tag = "2")]
    pub finding_details: ::core::option::Option<HybridFindingDetails>,
}
/// Populate to associate additional data with each finding.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridFindingDetails {
    /// Details about the container where the content being inspected is from.
    #[prost(message, optional, tag = "1")]
    pub container_details: ::core::option::Option<Container>,
    /// Offset in bytes of the line, from the beginning of the file, where the
    /// finding  is located. Populate if the item being scanned is only part of a
    /// bigger item, such as a shard of a file and you want to track the absolute
    /// position of the finding.
    #[prost(int64, tag = "2")]
    pub file_offset: i64,
    /// Offset of the row for tables. Populate if the row(s) being scanned are
    /// part of a bigger dataset and you want to keep track of their absolute
    /// position.
    #[prost(int64, tag = "3")]
    pub row_offset: i64,
    /// If the container is a table, additional information to make findings
    /// meaningful such as the columns that are primary keys. If not known ahead
    /// of time, can also be set within each inspect hybrid call and the two
    /// will be merged. Note that identifying_fields will only be stored to
    /// BigQuery, and only if the BigQuery action has been included.
    #[prost(message, optional, tag = "4")]
    pub table_options: ::core::option::Option<TableOptions>,
    /// Labels to represent user provided metadata about the data being inspected.
    /// If configured by the job, some key values may be required.
    /// The labels associated with `Finding`'s produced by hybrid
    /// inspection.
    ///
    /// Label keys must be between 1 and 63 characters long and must conform
    /// to the following regular expression: `\[a-z]([-a-z0-9]*[a-z0-9\])?`.
    ///
    /// Label values must be between 0 and 63 characters long and must conform
    /// to the regular expression `(\[a-z]([-a-z0-9]*[a-z0-9\])?)?`.
    ///
    /// No more than 10 labels can be associated with a given finding.
    ///
    /// Examples:
    /// * `"environment" : "production"`
    /// * `"pipeline" : "etl"`
    #[prost(map = "string, string", tag = "5")]
    pub labels:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
/// Quota exceeded errors will be thrown once quota has been met.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridInspectResponse {}
/// Operators available for comparing the value of fields.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RelationalOperator {
    /// Unused
    Unspecified = 0,
    /// Equal. Attempts to match even with incompatible types.
    EqualTo = 1,
    /// Not equal to. Attempts to match even with incompatible types.
    NotEqualTo = 2,
    /// Greater than.
    GreaterThan = 3,
    /// Less than.
    LessThan = 4,
    /// Greater than or equals.
    GreaterThanOrEquals = 5,
    /// Less than or equals.
    LessThanOrEquals = 6,
    /// Exists
    Exists = 7,
}
/// Type of the match which can be applied to different ways of matching, like
/// Dictionary, regular expression and intersecting with findings of another
/// info type.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MatchingType {
    /// Invalid.
    Unspecified = 0,
    /// Full match.
    ///
    /// - Dictionary: join of Dictionary results matched complete finding quote
    /// - Regex: all regex matches fill a finding quote start to end
    /// - Exclude info type: completely inside affecting info types findings
    FullMatch = 1,
    /// Partial match.
    ///
    /// - Dictionary: at least one of the tokens in the finding matches
    /// - Regex: substring of the finding matches
    /// - Exclude info type: intersects with affecting info types findings
    PartialMatch = 2,
    /// Inverse match.
    ///
    /// - Dictionary: no tokens in the finding match the dictionary
    /// - Regex: finding doesn't match the regex
    /// - Exclude info type: no intersection with affecting info types findings
    InverseMatch = 3,
}
/// Options describing which parts of the provided content should be scanned.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ContentOption {
    /// Includes entire content of a file or a data stream.
    ContentUnspecified = 0,
    /// Text content within the data, excluding any metadata.
    ContentText = 1,
    /// Images found in the data.
    ContentImage = 2,
}
/// Type of metadata containing the finding.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetadataType {
    /// Unused
    MetadatatypeUnspecified = 0,
    /// General file metadata provided by Cloud Storage.
    StorageMetadata = 2,
}
/// Parts of the APIs which use certain infoTypes.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum InfoTypeSupportedBy {
    /// Unused.
    EnumTypeUnspecified = 0,
    /// Supported by the inspect operations.
    Inspect = 1,
    /// Supported by the risk analysis operations.
    RiskAnalysis = 2,
}
/// An enum to represent the various types of DLP jobs.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DlpJobType {
    /// Unused
    Unspecified = 0,
    /// The job inspected Google Cloud for sensitive data.
    InspectJob = 1,
    /// The job executed a Risk Analysis computation.
    RiskAnalysisJob = 2,
}
/// State of a StoredInfoType version.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StoredInfoTypeState {
    /// Unused
    Unspecified = 0,
    /// StoredInfoType version is being created.
    Pending = 1,
    /// StoredInfoType version is ready for use.
    Ready = 2,
    /// StoredInfoType creation failed. All relevant error messages are returned in
    /// the `StoredInfoTypeVersion` message.
    Failed = 3,
    /// StoredInfoType is no longer valid because artifacts stored in
    /// user-controlled storage were modified. To fix an invalid StoredInfoType,
    /// use the `UpdateStoredInfoType` method to create a new version.
    Invalid = 4,
}
#[doc = r" Generated client implementations."]
pub mod dlp_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    #[doc = " The Cloud Data Loss Prevention (DLP) API is a service that allows clients"]
    #[doc = " to detect the presence of Personally Identifiable Information (PII) and other"]
    #[doc = " privacy-sensitive data in user-supplied, unstructured data streams, like text"]
    #[doc = " blocks or images."]
    #[doc = " The service also includes methods for sensitive data redaction and"]
    #[doc = " scheduling of data scans on Google Cloud Platform based data sets."]
    #[doc = ""]
    #[doc = " To learn more about concepts and find how-to guides see"]
    #[doc = " https://cloud.google.com/dlp/docs/."]
    #[derive(Debug, Clone)]
    pub struct DlpServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DlpServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::ResponseBody: Body + Send + 'static,
        T::Error: Into<StdError>,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DlpServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
                Into<StdError> + Send + Sync,
        {
            DlpServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        #[doc = r" Compress requests with `gzip`."]
        #[doc = r""]
        #[doc = r" This requires the server to support it otherwise it might respond with an"]
        #[doc = r" error."]
        pub fn send_gzip(mut self) -> Self {
            self.inner = self.inner.send_gzip();
            self
        }
        #[doc = r" Enable decompressing responses with `gzip`."]
        pub fn accept_gzip(mut self) -> Self {
            self.inner = self.inner.accept_gzip();
            self
        }
        #[doc = " Finds potentially sensitive info in content."]
        #[doc = " This method has limits on input size, processing time, and output size."]
        #[doc = ""]
        #[doc = " When no InfoTypes or CustomInfoTypes are specified in this request, the"]
        #[doc = " system will automatically choose what detectors to run. By default this may"]
        #[doc = " be all types, but may change over time as detectors are updated."]
        #[doc = ""]
        #[doc = " For how to guides, see https://cloud.google.com/dlp/docs/inspecting-images"]
        #[doc = " and https://cloud.google.com/dlp/docs/inspecting-text,"]
        pub async fn inspect_content(
            &mut self,
            request: impl tonic::IntoRequest<super::InspectContentRequest>,
        ) -> Result<tonic::Response<super::InspectContentResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/InspectContent",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Redacts potentially sensitive info from an image."]
        #[doc = " This method has limits on input size, processing time, and output size."]
        #[doc = " See https://cloud.google.com/dlp/docs/redacting-sensitive-data-images to"]
        #[doc = " learn more."]
        #[doc = ""]
        #[doc = " When no InfoTypes or CustomInfoTypes are specified in this request, the"]
        #[doc = " system will automatically choose what detectors to run. By default this may"]
        #[doc = " be all types, but may change over time as detectors are updated."]
        pub async fn redact_image(
            &mut self,
            request: impl tonic::IntoRequest<super::RedactImageRequest>,
        ) -> Result<tonic::Response<super::RedactImageResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/RedactImage",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " De-identifies potentially sensitive info from a ContentItem."]
        #[doc = " This method has limits on input size and output size."]
        #[doc = " See https://cloud.google.com/dlp/docs/deidentify-sensitive-data to"]
        #[doc = " learn more."]
        #[doc = ""]
        #[doc = " When no InfoTypes or CustomInfoTypes are specified in this request, the"]
        #[doc = " system will automatically choose what detectors to run. By default this may"]
        #[doc = " be all types, but may change over time as detectors are updated."]
        pub async fn deidentify_content(
            &mut self,
            request: impl tonic::IntoRequest<super::DeidentifyContentRequest>,
        ) -> Result<tonic::Response<super::DeidentifyContentResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeidentifyContent",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Re-identifies content that has been de-identified."]
        #[doc = " See"]
        #[doc = " https://cloud.google.com/dlp/docs/pseudonymization#re-identification_in_free_text_code_example"]
        #[doc = " to learn more."]
        pub async fn reidentify_content(
            &mut self,
            request: impl tonic::IntoRequest<super::ReidentifyContentRequest>,
        ) -> Result<tonic::Response<super::ReidentifyContentResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ReidentifyContent",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Returns a list of the sensitive information types that the DLP API"]
        #[doc = " supports. See https://cloud.google.com/dlp/docs/infotypes-reference to"]
        #[doc = " learn more."]
        pub async fn list_info_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListInfoTypesRequest>,
        ) -> Result<tonic::Response<super::ListInfoTypesResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListInfoTypes",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates an InspectTemplate for re-using frequently used configuration"]
        #[doc = " for inspecting content, images, and storage."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates to learn more."]
        pub async fn create_inspect_template(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateInspectTemplateRequest>,
        ) -> Result<tonic::Response<super::InspectTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CreateInspectTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates the InspectTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates to learn more."]
        pub async fn update_inspect_template(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateInspectTemplateRequest>,
        ) -> Result<tonic::Response<super::InspectTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/UpdateInspectTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets an InspectTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates to learn more."]
        pub async fn get_inspect_template(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInspectTemplateRequest>,
        ) -> Result<tonic::Response<super::InspectTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/GetInspectTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists InspectTemplates."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates to learn more."]
        pub async fn list_inspect_templates(
            &mut self,
            request: impl tonic::IntoRequest<super::ListInspectTemplatesRequest>,
        ) -> Result<tonic::Response<super::ListInspectTemplatesResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListInspectTemplates",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes an InspectTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates to learn more."]
        pub async fn delete_inspect_template(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteInspectTemplateRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeleteInspectTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a DeidentifyTemplate for re-using frequently used configuration"]
        #[doc = " for de-identifying content, images, and storage."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates-deid to learn"]
        #[doc = " more."]
        pub async fn create_deidentify_template(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDeidentifyTemplateRequest>,
        ) -> Result<tonic::Response<super::DeidentifyTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CreateDeidentifyTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates the DeidentifyTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates-deid to learn"]
        #[doc = " more."]
        pub async fn update_deidentify_template(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDeidentifyTemplateRequest>,
        ) -> Result<tonic::Response<super::DeidentifyTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/UpdateDeidentifyTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets a DeidentifyTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates-deid to learn"]
        #[doc = " more."]
        pub async fn get_deidentify_template(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeidentifyTemplateRequest>,
        ) -> Result<tonic::Response<super::DeidentifyTemplate>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/GetDeidentifyTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists DeidentifyTemplates."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates-deid to learn"]
        #[doc = " more."]
        pub async fn list_deidentify_templates(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeidentifyTemplatesRequest>,
        ) -> Result<tonic::Response<super::ListDeidentifyTemplatesResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListDeidentifyTemplates",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a DeidentifyTemplate."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-templates-deid to learn"]
        #[doc = " more."]
        pub async fn delete_deidentify_template(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDeidentifyTemplateRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeleteDeidentifyTemplate",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a job trigger to run DLP actions such as scanning storage for"]
        #[doc = " sensitive information on a set schedule."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-job-triggers to learn more."]
        pub async fn create_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateJobTriggerRequest>,
        ) -> Result<tonic::Response<super::JobTrigger>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CreateJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates a job trigger."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-job-triggers to learn more."]
        pub async fn update_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateJobTriggerRequest>,
        ) -> Result<tonic::Response<super::JobTrigger>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/UpdateJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Inspect hybrid content and store findings to a trigger. The inspection"]
        #[doc = " will be processed asynchronously. To review the findings monitor the"]
        #[doc = " jobs within the trigger."]
        #[doc = " Early access feature is in a pre-release state and might change or have"]
        #[doc = " limited support. For more information, see"]
        #[doc = " https://cloud.google.com/products#product-launch-stages."]
        pub async fn hybrid_inspect_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::HybridInspectJobTriggerRequest>,
        ) -> Result<tonic::Response<super::HybridInspectResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/HybridInspectJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets a job trigger."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-job-triggers to learn more."]
        pub async fn get_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::GetJobTriggerRequest>,
        ) -> Result<tonic::Response<super::JobTrigger>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/GetJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists job triggers."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-job-triggers to learn more."]
        pub async fn list_job_triggers(
            &mut self,
            request: impl tonic::IntoRequest<super::ListJobTriggersRequest>,
        ) -> Result<tonic::Response<super::ListJobTriggersResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListJobTriggers",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a job trigger."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-job-triggers to learn more."]
        pub async fn delete_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteJobTriggerRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeleteJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Activate a job trigger. Causes the immediate execute of a trigger"]
        #[doc = " instead of waiting on the trigger event to occur."]
        pub async fn activate_job_trigger(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivateJobTriggerRequest>,
        ) -> Result<tonic::Response<super::DlpJob>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ActivateJobTrigger",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a new job to inspect storage or calculate risk metrics."]
        #[doc = " See https://cloud.google.com/dlp/docs/inspecting-storage and"]
        #[doc = " https://cloud.google.com/dlp/docs/compute-risk-analysis to learn more."]
        #[doc = ""]
        #[doc = " When no InfoTypes or CustomInfoTypes are specified in inspect jobs, the"]
        #[doc = " system will automatically choose what detectors to run. By default this may"]
        #[doc = " be all types, but may change over time as detectors are updated."]
        pub async fn create_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDlpJobRequest>,
        ) -> Result<tonic::Response<super::DlpJob>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CreateDlpJob",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists DlpJobs that match the specified filter in the request."]
        #[doc = " See https://cloud.google.com/dlp/docs/inspecting-storage and"]
        #[doc = " https://cloud.google.com/dlp/docs/compute-risk-analysis to learn more."]
        pub async fn list_dlp_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDlpJobsRequest>,
        ) -> Result<tonic::Response<super::ListDlpJobsResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListDlpJobs",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets the latest state of a long-running DlpJob."]
        #[doc = " See https://cloud.google.com/dlp/docs/inspecting-storage and"]
        #[doc = " https://cloud.google.com/dlp/docs/compute-risk-analysis to learn more."]
        pub async fn get_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDlpJobRequest>,
        ) -> Result<tonic::Response<super::DlpJob>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/google.privacy.dlp.v2.DlpService/GetDlpJob");
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a long-running DlpJob. This method indicates that the client is"]
        #[doc = " no longer interested in the DlpJob result. The job will be cancelled if"]
        #[doc = " possible."]
        #[doc = " See https://cloud.google.com/dlp/docs/inspecting-storage and"]
        #[doc = " https://cloud.google.com/dlp/docs/compute-risk-analysis to learn more."]
        pub async fn delete_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDlpJobRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeleteDlpJob",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Starts asynchronous cancellation on a long-running DlpJob. The server"]
        #[doc = " makes a best effort to cancel the DlpJob, but success is not"]
        #[doc = " guaranteed."]
        #[doc = " See https://cloud.google.com/dlp/docs/inspecting-storage and"]
        #[doc = " https://cloud.google.com/dlp/docs/compute-risk-analysis to learn more."]
        pub async fn cancel_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelDlpJobRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CancelDlpJob",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a pre-built stored infoType to be used for inspection."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-stored-infotypes to"]
        #[doc = " learn more."]
        pub async fn create_stored_info_type(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateStoredInfoTypeRequest>,
        ) -> Result<tonic::Response<super::StoredInfoType>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/CreateStoredInfoType",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates the stored infoType by creating a new version. The existing version"]
        #[doc = " will continue to be used until the new version is ready."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-stored-infotypes to"]
        #[doc = " learn more."]
        pub async fn update_stored_info_type(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateStoredInfoTypeRequest>,
        ) -> Result<tonic::Response<super::StoredInfoType>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/UpdateStoredInfoType",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets a stored infoType."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-stored-infotypes to"]
        #[doc = " learn more."]
        pub async fn get_stored_info_type(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStoredInfoTypeRequest>,
        ) -> Result<tonic::Response<super::StoredInfoType>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/GetStoredInfoType",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists stored infoTypes."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-stored-infotypes to"]
        #[doc = " learn more."]
        pub async fn list_stored_info_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListStoredInfoTypesRequest>,
        ) -> Result<tonic::Response<super::ListStoredInfoTypesResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/ListStoredInfoTypes",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a stored infoType."]
        #[doc = " See https://cloud.google.com/dlp/docs/creating-stored-infotypes to"]
        #[doc = " learn more."]
        pub async fn delete_stored_info_type(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteStoredInfoTypeRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/DeleteStoredInfoType",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Inspect hybrid content and store findings to a job."]
        #[doc = " To review the findings inspect the job. Inspection will occur"]
        #[doc = " asynchronously."]
        #[doc = " Early access feature is in a pre-release state and might change or have"]
        #[doc = " limited support. For more information, see"]
        #[doc = " https://cloud.google.com/products#product-launch-stages."]
        pub async fn hybrid_inspect_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::HybridInspectDlpJobRequest>,
        ) -> Result<tonic::Response<super::HybridInspectResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/HybridInspectDlpJob",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Finish a running hybrid DlpJob. Triggers the finalization steps and running"]
        #[doc = " of any enabled actions that have not yet run."]
        #[doc = " Early access feature is in a pre-release state and might change or have"]
        #[doc = " limited support. For more information, see"]
        #[doc = " https://cloud.google.com/products#product-launch-stages."]
        pub async fn finish_dlp_job(
            &mut self,
            request: impl tonic::IntoRequest<super::FinishDlpJobRequest>,
        ) -> Result<tonic::Response<()>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.privacy.dlp.v2.DlpService/FinishDlpJob",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
}