<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="dlp_v2.html">Cloud Data Loss Prevention (DLP) API</a> . <a href="dlp_v2.projects.html">projects</a> . <a href="dlp_v2.projects.inspectTemplates.html">inspectTemplates</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#create">create(parent, body, x__xgafv=None)</a></code></p>
<p class="firstline">Creates an InspectTemplate for re-using frequently used configuration</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes an InspectTemplate.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Gets an InspectTemplate.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, orderBy=None, pageToken=None, x__xgafv=None, pageSize=None)</a></code></p>
<p class="firstline">Lists InspectTemplates.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(name, body, x__xgafv=None)</a></code></p>
<p class="firstline">Updates the InspectTemplate.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="create">create(parent, body, x__xgafv=None)</code>
  <pre>Creates an InspectTemplate for re-using frequently used configuration
for inspecting content, images, and storage.
See https://cloud.google.com/dlp/docs/creating-templates to learn more.

Args:
  parent: string, The parent resource name, for example projects/my-project-id or
organizations/my-org-id. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Request message for CreateInspectTemplate.
    "inspectTemplate": { # The inspectTemplate contains a configuration (set of types of sensitive data # The InspectTemplate to create.
        # 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.
      "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
      "displayName": "A String", # Display name (max 256 chars).
      "description": "A String", # Short description (max 256 chars).
      "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
          # When used with redactContent only info_types and min_likelihood are currently
          # used.
        "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
        "limits": {
          "maxFindingsPerRequest": 42, # 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.
          "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
            { # Max findings configuration per infoType, per content item or long
                # running DlpJob.
              "infoType": { # Type of information detected by the API. # 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.
                "name": "A String", # 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. InfoType names should conform to the pattern
                    # [a-zA-Z0-9_]{1,64}.
              },
              "maxFindings": 42, # Max findings limit for the given infoType.
            },
          ],
          "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
              # When set within `InspectDataSourceRequest`,
              # the maximum returned is 2000 regardless if this is set higher.
              # When set within `InspectContentRequest`, this field is ignored.
        },
        "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
            # POSSIBLE.
            # See https://cloud.google.com/dlp/docs/likelihood to learn more.
        "customInfoTypes": [ # CustomInfoTypes provided by the user. See
            # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
          { # Custom information type provided by the user. Used to find domain-specific
              # sensitive information configurable to the data in question.
            "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
              "pattern": "A String", # Pattern defining the regular expression. Its syntax
                  # (https://github.com/google/re2/wiki/Syntax) can be found under the
                  # google/re2 repository on GitHub.
              "groupIndexes": [ # The index of the submatch to extract as findings. When not
                  # specified, the entire match is returned. No more than 3 may be included.
                42,
              ],
            },
            "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
                # support reversing.
                # such as
                # [`CryptoReplaceFfxFpeConfig`](/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`.
            },
            "infoType": { # Type of information detected by the API. # 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.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
            "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
                # 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.
              "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                "words": [ # 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]
                  "A String",
                ],
              },
              "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                  # is accepted.
                "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                    # Example: gs://[BUCKET_NAME]/dictionary.txt
              },
            },
            "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
                # `InspectDataSource`. Not currently supported in `InspectContent`.
              "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                  # `organizations/433245324/storedInfoTypes/432452342` or
                  # `projects/project-id/storedInfoTypes/432452342`.
              "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                  # inspection was created. Output-only field, populated by the system.
            },
            "detectionRules": [ # 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.
              { # 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.
                "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                    # proximity of hotwords.
                  "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                      # rule.
                    "windowAfter": 42, # Number of characters after the finding to consider.
                    "windowBefore": 42, # Number of characters before the finding to consider.
                  },
                  "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                      # part of a detection rule.
                    "relativeLikelihood": 42, # 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`.
                    "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                  },
                },
              },
            ],
            "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
                # to be returned. It still can be used for rules matching.
            "likelihood": "A String", # 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.
          },
        ],
        "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
            # included in the response; see Finding.quote.
        "ruleSet": [ # 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.
          { # 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.
            "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
              { # A single inspection rule to be applied to infoTypes, specified in
                  # `InspectionRuleSet`.
                "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                    # proximity of hotwords.
                  "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                      # rule.
                    "windowAfter": 42, # Number of characters after the finding to consider.
                    "windowBefore": 42, # Number of characters before the finding to consider.
                  },
                  "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                      # part of a detection rule.
                    "relativeLikelihood": 42, # 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`.
                    "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                  },
                },
                "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                    # `InspectionRuleSet` are removed from results.
                  "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                    "infoTypes": [ # 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.
                      { # Type of information detected by the API.
                        "name": "A String", # 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. InfoType names should conform to the pattern
                            # [a-zA-Z0-9_]{1,64}.
                      },
                    ],
                  },
                  "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                      # 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.
                    "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                      "words": [ # 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]
                        "A String",
                      ],
                    },
                    "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                        # is accepted.
                      "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                          # Example: gs://[BUCKET_NAME]/dictionary.txt
                    },
                  },
                  "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                },
              },
            ],
            "infoTypes": [ # List of infoTypes this rule set is applied to.
              { # Type of information detected by the API.
                "name": "A String", # 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. InfoType names should conform to the pattern
                    # [a-zA-Z0-9_]{1,64}.
              },
            ],
          },
        ],
        "contentOptions": [ # List of options defining data content to scan.
            # If empty, text, images, and other content will be included.
          "A String",
        ],
        "infoTypes": [ # 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.
            #
            # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
            # but may change over time as new InfoTypes are added. If you need precise
            # control and predictability as to what detectors are run you should specify
            # specific InfoTypes listed in the reference.
          { # Type of information detected by the API.
            "name": "A String", # 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. InfoType names should conform to the pattern
                # [a-zA-Z0-9_]{1,64}.
          },
        ],
      },
      "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
      "name": "A String", # The template name. Output only.
          #
          # The template will have one of the following formats:
          # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
          # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
    },
    "templateId": "A String", # 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.
  }

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # 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.
    "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
    "displayName": "A String", # Display name (max 256 chars).
    "description": "A String", # Short description (max 256 chars).
    "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
        # When used with redactContent only info_types and min_likelihood are currently
        # used.
      "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
      "limits": {
        "maxFindingsPerRequest": 42, # 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.
        "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
          { # Max findings configuration per infoType, per content item or long
              # running DlpJob.
            "infoType": { # Type of information detected by the API. # 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.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
            "maxFindings": 42, # Max findings limit for the given infoType.
          },
        ],
        "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
            # When set within `InspectDataSourceRequest`,
            # the maximum returned is 2000 regardless if this is set higher.
            # When set within `InspectContentRequest`, this field is ignored.
      },
      "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
          # POSSIBLE.
          # See https://cloud.google.com/dlp/docs/likelihood to learn more.
      "customInfoTypes": [ # CustomInfoTypes provided by the user. See
          # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
        { # Custom information type provided by the user. Used to find domain-specific
            # sensitive information configurable to the data in question.
          "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
            "pattern": "A String", # Pattern defining the regular expression. Its syntax
                # (https://github.com/google/re2/wiki/Syntax) can be found under the
                # google/re2 repository on GitHub.
            "groupIndexes": [ # The index of the submatch to extract as findings. When not
                # specified, the entire match is returned. No more than 3 may be included.
              42,
            ],
          },
          "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
              # support reversing.
              # such as
              # [`CryptoReplaceFfxFpeConfig`](/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`.
          },
          "infoType": { # Type of information detected by the API. # 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.
            "name": "A String", # 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. InfoType names should conform to the pattern
                # [a-zA-Z0-9_]{1,64}.
          },
          "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
              # 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.
            "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
              "words": [ # 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]
                "A String",
              ],
            },
            "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                # is accepted.
              "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                  # Example: gs://[BUCKET_NAME]/dictionary.txt
            },
          },
          "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
              # `InspectDataSource`. Not currently supported in `InspectContent`.
            "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                # `organizations/433245324/storedInfoTypes/432452342` or
                # `projects/project-id/storedInfoTypes/432452342`.
            "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                # inspection was created. Output-only field, populated by the system.
          },
          "detectionRules": [ # 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.
            { # 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.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
            },
          ],
          "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
              # to be returned. It still can be used for rules matching.
          "likelihood": "A String", # 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.
        },
      ],
      "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
          # included in the response; see Finding.quote.
      "ruleSet": [ # 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.
        { # 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.
          "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
            { # A single inspection rule to be applied to infoTypes, specified in
                # `InspectionRuleSet`.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
              "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                  # `InspectionRuleSet` are removed from results.
                "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                  "infoTypes": [ # 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.
                    { # Type of information detected by the API.
                      "name": "A String", # 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. InfoType names should conform to the pattern
                          # [a-zA-Z0-9_]{1,64}.
                    },
                  ],
                },
                "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                    # 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.
                  "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                    "words": [ # 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]
                      "A String",
                    ],
                  },
                  "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                      # is accepted.
                    "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                        # Example: gs://[BUCKET_NAME]/dictionary.txt
                  },
                },
                "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
              },
            },
          ],
          "infoTypes": [ # List of infoTypes this rule set is applied to.
            { # Type of information detected by the API.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
          ],
        },
      ],
      "contentOptions": [ # List of options defining data content to scan.
          # If empty, text, images, and other content will be included.
        "A String",
      ],
      "infoTypes": [ # 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.
          #
          # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
          # but may change over time as new InfoTypes are added. If you need precise
          # control and predictability as to what detectors are run you should specify
          # specific InfoTypes listed in the reference.
        { # Type of information detected by the API.
          "name": "A String", # 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. InfoType names should conform to the pattern
              # [a-zA-Z0-9_]{1,64}.
        },
      ],
    },
    "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
    "name": "A String", # The template name. Output only.
        #
        # The template will have one of the following formats:
        # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
        # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  }</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Deletes an InspectTemplate.
See https://cloud.google.com/dlp/docs/creating-templates to learn more.

Args:
  name: string, Resource name of the organization and inspectTemplate to be deleted, for
example `organizations/433245324/inspectTemplates/432452342` or
projects/project-id/inspectTemplates/432452342. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated
      # empty messages in your APIs. A typical example is to use it as the request
      # or the response type of an API method. For instance:
      #
      #     service Foo {
      #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
      #     }
      #
      # The JSON representation for `Empty` is empty JSON object `{}`.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, x__xgafv=None)</code>
  <pre>Gets an InspectTemplate.
See https://cloud.google.com/dlp/docs/creating-templates to learn more.

Args:
  name: string, Resource name of the organization and inspectTemplate to be read, for
example `organizations/433245324/inspectTemplates/432452342` or
projects/project-id/inspectTemplates/432452342. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # 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.
    "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
    "displayName": "A String", # Display name (max 256 chars).
    "description": "A String", # Short description (max 256 chars).
    "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
        # When used with redactContent only info_types and min_likelihood are currently
        # used.
      "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
      "limits": {
        "maxFindingsPerRequest": 42, # 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.
        "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
          { # Max findings configuration per infoType, per content item or long
              # running DlpJob.
            "infoType": { # Type of information detected by the API. # 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.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
            "maxFindings": 42, # Max findings limit for the given infoType.
          },
        ],
        "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
            # When set within `InspectDataSourceRequest`,
            # the maximum returned is 2000 regardless if this is set higher.
            # When set within `InspectContentRequest`, this field is ignored.
      },
      "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
          # POSSIBLE.
          # See https://cloud.google.com/dlp/docs/likelihood to learn more.
      "customInfoTypes": [ # CustomInfoTypes provided by the user. See
          # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
        { # Custom information type provided by the user. Used to find domain-specific
            # sensitive information configurable to the data in question.
          "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
            "pattern": "A String", # Pattern defining the regular expression. Its syntax
                # (https://github.com/google/re2/wiki/Syntax) can be found under the
                # google/re2 repository on GitHub.
            "groupIndexes": [ # The index of the submatch to extract as findings. When not
                # specified, the entire match is returned. No more than 3 may be included.
              42,
            ],
          },
          "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
              # support reversing.
              # such as
              # [`CryptoReplaceFfxFpeConfig`](/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`.
          },
          "infoType": { # Type of information detected by the API. # 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.
            "name": "A String", # 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. InfoType names should conform to the pattern
                # [a-zA-Z0-9_]{1,64}.
          },
          "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
              # 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.
            "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
              "words": [ # 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]
                "A String",
              ],
            },
            "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                # is accepted.
              "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                  # Example: gs://[BUCKET_NAME]/dictionary.txt
            },
          },
          "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
              # `InspectDataSource`. Not currently supported in `InspectContent`.
            "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                # `organizations/433245324/storedInfoTypes/432452342` or
                # `projects/project-id/storedInfoTypes/432452342`.
            "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                # inspection was created. Output-only field, populated by the system.
          },
          "detectionRules": [ # 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.
            { # 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.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
            },
          ],
          "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
              # to be returned. It still can be used for rules matching.
          "likelihood": "A String", # 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.
        },
      ],
      "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
          # included in the response; see Finding.quote.
      "ruleSet": [ # 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.
        { # 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.
          "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
            { # A single inspection rule to be applied to infoTypes, specified in
                # `InspectionRuleSet`.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
              "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                  # `InspectionRuleSet` are removed from results.
                "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                  "infoTypes": [ # 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.
                    { # Type of information detected by the API.
                      "name": "A String", # 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. InfoType names should conform to the pattern
                          # [a-zA-Z0-9_]{1,64}.
                    },
                  ],
                },
                "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                    # 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.
                  "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                    "words": [ # 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]
                      "A String",
                    ],
                  },
                  "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                      # is accepted.
                    "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                        # Example: gs://[BUCKET_NAME]/dictionary.txt
                  },
                },
                "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
              },
            },
          ],
          "infoTypes": [ # List of infoTypes this rule set is applied to.
            { # Type of information detected by the API.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
          ],
        },
      ],
      "contentOptions": [ # List of options defining data content to scan.
          # If empty, text, images, and other content will be included.
        "A String",
      ],
      "infoTypes": [ # 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.
          #
          # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
          # but may change over time as new InfoTypes are added. If you need precise
          # control and predictability as to what detectors are run you should specify
          # specific InfoTypes listed in the reference.
        { # Type of information detected by the API.
          "name": "A String", # 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. InfoType names should conform to the pattern
              # [a-zA-Z0-9_]{1,64}.
        },
      ],
    },
    "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
    "name": "A String", # The template name. Output only.
        #
        # The template will have one of the following formats:
        # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
        # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, orderBy=None, pageToken=None, x__xgafv=None, pageSize=None)</code>
  <pre>Lists InspectTemplates.
See https://cloud.google.com/dlp/docs/creating-templates to learn more.

Args:
  parent: string, The parent resource name, for example projects/my-project-id or
organizations/my-org-id. (required)
  orderBy: string, Optional 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.
  pageToken: string, Optional page token to continue retrieval. Comes from previous call
to `ListInspectTemplates`.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
  pageSize: integer, Optional size of the page, can be limited by server. If zero server returns
a page of max size 100.

Returns:
  An object of the form:

    { # Response message for ListInspectTemplates.
    "nextPageToken": "A String", # If the next page is available then the next page token to be used
        # in following ListInspectTemplates request.
    "inspectTemplates": [ # List of inspectTemplates, up to page_size in ListInspectTemplatesRequest.
      { # 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.
        "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
        "displayName": "A String", # Display name (max 256 chars).
        "description": "A String", # Short description (max 256 chars).
        "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
            # When used with redactContent only info_types and min_likelihood are currently
            # used.
          "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
          "limits": {
            "maxFindingsPerRequest": 42, # 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.
            "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
              { # Max findings configuration per infoType, per content item or long
                  # running DlpJob.
                "infoType": { # Type of information detected by the API. # 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.
                  "name": "A String", # 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. InfoType names should conform to the pattern
                      # [a-zA-Z0-9_]{1,64}.
                },
                "maxFindings": 42, # Max findings limit for the given infoType.
              },
            ],
            "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                # When set within `InspectDataSourceRequest`,
                # the maximum returned is 2000 regardless if this is set higher.
                # When set within `InspectContentRequest`, this field is ignored.
          },
          "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
              # POSSIBLE.
              # See https://cloud.google.com/dlp/docs/likelihood to learn more.
          "customInfoTypes": [ # CustomInfoTypes provided by the user. See
              # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
            { # Custom information type provided by the user. Used to find domain-specific
                # sensitive information configurable to the data in question.
              "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                "pattern": "A String", # Pattern defining the regular expression. Its syntax
                    # (https://github.com/google/re2/wiki/Syntax) can be found under the
                    # google/re2 repository on GitHub.
                "groupIndexes": [ # The index of the submatch to extract as findings. When not
                    # specified, the entire match is returned. No more than 3 may be included.
                  42,
                ],
              },
              "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
                  # support reversing.
                  # such as
                  # [`CryptoReplaceFfxFpeConfig`](/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`.
              },
              "infoType": { # Type of information detected by the API. # 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.
                "name": "A String", # 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. InfoType names should conform to the pattern
                    # [a-zA-Z0-9_]{1,64}.
              },
              "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
                  # 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.
                "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                  "words": [ # 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]
                    "A String",
                  ],
                },
                "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                    # is accepted.
                  "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                      # Example: gs://[BUCKET_NAME]/dictionary.txt
                },
              },
              "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
                  # `InspectDataSource`. Not currently supported in `InspectContent`.
                "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                    # `organizations/433245324/storedInfoTypes/432452342` or
                    # `projects/project-id/storedInfoTypes/432452342`.
                "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                    # inspection was created. Output-only field, populated by the system.
              },
              "detectionRules": [ # 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.
                { # 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.
                  "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                      # proximity of hotwords.
                    "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                        # rule.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "pattern": "A String", # Pattern defining the regular expression. Its syntax
                          # (https://github.com/google/re2/wiki/Syntax) can be found under the
                          # google/re2 repository on GitHub.
                      "groupIndexes": [ # The index of the submatch to extract as findings. When not
                          # specified, the entire match is returned. No more than 3 may be included.
                        42,
                      ],
                    },
                    "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                        # part of a detection rule.
                      "relativeLikelihood": 42, # 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`.
                      "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                    },
                  },
                },
              ],
              "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
                  # to be returned. It still can be used for rules matching.
              "likelihood": "A String", # 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.
            },
          ],
          "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
              # included in the response; see Finding.quote.
          "ruleSet": [ # 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.
            { # 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.
              "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
                { # A single inspection rule to be applied to infoTypes, specified in
                    # `InspectionRuleSet`.
                  "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                      # proximity of hotwords.
                    "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                        # rule.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "pattern": "A String", # Pattern defining the regular expression. Its syntax
                          # (https://github.com/google/re2/wiki/Syntax) can be found under the
                          # google/re2 repository on GitHub.
                      "groupIndexes": [ # The index of the submatch to extract as findings. When not
                          # specified, the entire match is returned. No more than 3 may be included.
                        42,
                      ],
                    },
                    "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                        # part of a detection rule.
                      "relativeLikelihood": 42, # 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`.
                      "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                    },
                  },
                  "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                      # `InspectionRuleSet` are removed from results.
                    "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                      "pattern": "A String", # Pattern defining the regular expression. Its syntax
                          # (https://github.com/google/re2/wiki/Syntax) can be found under the
                          # google/re2 repository on GitHub.
                      "groupIndexes": [ # The index of the submatch to extract as findings. When not
                          # specified, the entire match is returned. No more than 3 may be included.
                        42,
                      ],
                    },
                    "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                      "infoTypes": [ # 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.
                        { # Type of information detected by the API.
                          "name": "A String", # 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. InfoType names should conform to the pattern
                              # [a-zA-Z0-9_]{1,64}.
                        },
                      ],
                    },
                    "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                        # 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.
                      "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                        "words": [ # 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]
                          "A String",
                        ],
                      },
                      "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                          # is accepted.
                        "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                            # Example: gs://[BUCKET_NAME]/dictionary.txt
                      },
                    },
                    "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                  },
                },
              ],
              "infoTypes": [ # List of infoTypes this rule set is applied to.
                { # Type of information detected by the API.
                  "name": "A String", # 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. InfoType names should conform to the pattern
                      # [a-zA-Z0-9_]{1,64}.
                },
              ],
            },
          ],
          "contentOptions": [ # List of options defining data content to scan.
              # If empty, text, images, and other content will be included.
            "A String",
          ],
          "infoTypes": [ # 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.
              #
              # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
              # but may change over time as new InfoTypes are added. If you need precise
              # control and predictability as to what detectors are run you should specify
              # specific InfoTypes listed in the reference.
            { # Type of information detected by the API.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
          ],
        },
        "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
        "name": "A String", # The template name. Output only.
            #
            # The template will have one of the following formats:
            # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
            # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call 'execute()' on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(name, body, x__xgafv=None)</code>
  <pre>Updates the InspectTemplate.
See https://cloud.google.com/dlp/docs/creating-templates to learn more.

Args:
  name: string, Resource name of organization and inspectTemplate to be updated, for
example `organizations/433245324/inspectTemplates/432452342` or
projects/project-id/inspectTemplates/432452342. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # Request message for UpdateInspectTemplate.
    "updateMask": "A String", # Mask to control which fields get updated.
    "inspectTemplate": { # The inspectTemplate contains a configuration (set of types of sensitive data # New InspectTemplate value.
        # 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.
      "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
      "displayName": "A String", # Display name (max 256 chars).
      "description": "A String", # Short description (max 256 chars).
      "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
          # When used with redactContent only info_types and min_likelihood are currently
          # used.
        "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
        "limits": {
          "maxFindingsPerRequest": 42, # 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.
          "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
            { # Max findings configuration per infoType, per content item or long
                # running DlpJob.
              "infoType": { # Type of information detected by the API. # 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.
                "name": "A String", # 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. InfoType names should conform to the pattern
                    # [a-zA-Z0-9_]{1,64}.
              },
              "maxFindings": 42, # Max findings limit for the given infoType.
            },
          ],
          "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
              # When set within `InspectDataSourceRequest`,
              # the maximum returned is 2000 regardless if this is set higher.
              # When set within `InspectContentRequest`, this field is ignored.
        },
        "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
            # POSSIBLE.
            # See https://cloud.google.com/dlp/docs/likelihood to learn more.
        "customInfoTypes": [ # CustomInfoTypes provided by the user. See
            # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
          { # Custom information type provided by the user. Used to find domain-specific
              # sensitive information configurable to the data in question.
            "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
              "pattern": "A String", # Pattern defining the regular expression. Its syntax
                  # (https://github.com/google/re2/wiki/Syntax) can be found under the
                  # google/re2 repository on GitHub.
              "groupIndexes": [ # The index of the submatch to extract as findings. When not
                  # specified, the entire match is returned. No more than 3 may be included.
                42,
              ],
            },
            "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
                # support reversing.
                # such as
                # [`CryptoReplaceFfxFpeConfig`](/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`.
            },
            "infoType": { # Type of information detected by the API. # 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.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
            "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
                # 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.
              "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                "words": [ # 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]
                  "A String",
                ],
              },
              "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                  # is accepted.
                "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                    # Example: gs://[BUCKET_NAME]/dictionary.txt
              },
            },
            "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
                # `InspectDataSource`. Not currently supported in `InspectContent`.
              "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                  # `organizations/433245324/storedInfoTypes/432452342` or
                  # `projects/project-id/storedInfoTypes/432452342`.
              "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                  # inspection was created. Output-only field, populated by the system.
            },
            "detectionRules": [ # 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.
              { # 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.
                "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                    # proximity of hotwords.
                  "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                      # rule.
                    "windowAfter": 42, # Number of characters after the finding to consider.
                    "windowBefore": 42, # Number of characters before the finding to consider.
                  },
                  "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                      # part of a detection rule.
                    "relativeLikelihood": 42, # 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`.
                    "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                  },
                },
              },
            ],
            "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
                # to be returned. It still can be used for rules matching.
            "likelihood": "A String", # 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.
          },
        ],
        "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
            # included in the response; see Finding.quote.
        "ruleSet": [ # 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.
          { # 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.
            "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
              { # A single inspection rule to be applied to infoTypes, specified in
                  # `InspectionRuleSet`.
                "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                    # proximity of hotwords.
                  "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                      # rule.
                    "windowAfter": 42, # Number of characters after the finding to consider.
                    "windowBefore": 42, # Number of characters before the finding to consider.
                  },
                  "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                      # part of a detection rule.
                    "relativeLikelihood": 42, # 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`.
                    "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                  },
                },
                "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                    # `InspectionRuleSet` are removed from results.
                  "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                    "pattern": "A String", # Pattern defining the regular expression. Its syntax
                        # (https://github.com/google/re2/wiki/Syntax) can be found under the
                        # google/re2 repository on GitHub.
                    "groupIndexes": [ # The index of the submatch to extract as findings. When not
                        # specified, the entire match is returned. No more than 3 may be included.
                      42,
                    ],
                  },
                  "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                    "infoTypes": [ # 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.
                      { # Type of information detected by the API.
                        "name": "A String", # 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. InfoType names should conform to the pattern
                            # [a-zA-Z0-9_]{1,64}.
                      },
                    ],
                  },
                  "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                      # 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.
                    "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                      "words": [ # 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]
                        "A String",
                      ],
                    },
                    "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                        # is accepted.
                      "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                          # Example: gs://[BUCKET_NAME]/dictionary.txt
                    },
                  },
                  "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                },
              },
            ],
            "infoTypes": [ # List of infoTypes this rule set is applied to.
              { # Type of information detected by the API.
                "name": "A String", # 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. InfoType names should conform to the pattern
                    # [a-zA-Z0-9_]{1,64}.
              },
            ],
          },
        ],
        "contentOptions": [ # List of options defining data content to scan.
            # If empty, text, images, and other content will be included.
          "A String",
        ],
        "infoTypes": [ # 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.
            #
            # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
            # but may change over time as new InfoTypes are added. If you need precise
            # control and predictability as to what detectors are run you should specify
            # specific InfoTypes listed in the reference.
          { # Type of information detected by the API.
            "name": "A String", # 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. InfoType names should conform to the pattern
                # [a-zA-Z0-9_]{1,64}.
          },
        ],
      },
      "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
      "name": "A String", # The template name. Output only.
          #
          # The template will have one of the following formats:
          # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
          # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
    },
  }

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # 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.
    "updateTime": "A String", # The last update timestamp of a inspectTemplate, output only field.
    "displayName": "A String", # Display name (max 256 chars).
    "description": "A String", # Short description (max 256 chars).
    "inspectConfig": { # Configuration description of the scanning process. # The core content of the template. Configuration of the scanning process.
        # When used with redactContent only info_types and min_likelihood are currently
        # used.
      "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
      "limits": {
        "maxFindingsPerRequest": 42, # 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.
        "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
          { # Max findings configuration per infoType, per content item or long
              # running DlpJob.
            "infoType": { # Type of information detected by the API. # 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.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
            "maxFindings": 42, # Max findings limit for the given infoType.
          },
        ],
        "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
            # When set within `InspectDataSourceRequest`,
            # the maximum returned is 2000 regardless if this is set higher.
            # When set within `InspectContentRequest`, this field is ignored.
      },
      "minLikelihood": "A String", # Only returns findings equal or above this threshold. The default is
          # POSSIBLE.
          # See https://cloud.google.com/dlp/docs/likelihood to learn more.
      "customInfoTypes": [ # CustomInfoTypes provided by the user. See
          # https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
        { # Custom information type provided by the user. Used to find domain-specific
            # sensitive information configurable to the data in question.
          "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
            "pattern": "A String", # Pattern defining the regular expression. Its syntax
                # (https://github.com/google/re2/wiki/Syntax) can be found under the
                # google/re2 repository on GitHub.
            "groupIndexes": [ # The index of the submatch to extract as findings. When not
                # specified, the entire match is returned. No more than 3 may be included.
              42,
            ],
          },
          "surrogateType": { # Message for detecting output from deidentification transformations # Message for detecting output from deidentification transformations that
              # support reversing.
              # such as
              # [`CryptoReplaceFfxFpeConfig`](/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`.
          },
          "infoType": { # Type of information detected by the API. # 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.
            "name": "A String", # 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. InfoType names should conform to the pattern
                # [a-zA-Z0-9_]{1,64}.
          },
          "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # A list of phrases to detect as a CustomInfoType.
              # 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.
            "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
              "words": [ # 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]
                "A String",
              ],
            },
            "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                # is accepted.
              "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                  # Example: gs://[BUCKET_NAME]/dictionary.txt
            },
          },
          "storedType": { # A reference to a StoredInfoType to use with scanning. # Load an existing `StoredInfoType` resource for use in
              # `InspectDataSource`. Not currently supported in `InspectContent`.
            "name": "A String", # Resource name of the requested `StoredInfoType`, for example
                # `organizations/433245324/storedInfoTypes/432452342` or
                # `projects/project-id/storedInfoTypes/432452342`.
            "createTime": "A String", # Timestamp indicating when the version of the `StoredInfoType` used for
                # inspection was created. Output-only field, populated by the system.
          },
          "detectionRules": [ # 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.
            { # 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.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
            },
          ],
          "exclusionType": "A String", # If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding
              # to be returned. It still can be used for rules matching.
          "likelihood": "A String", # 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.
        },
      ],
      "includeQuote": True or False, # When true, a contextual quote from the data that triggered a finding is
          # included in the response; see Finding.quote.
      "ruleSet": [ # 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.
        { # 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.
          "rules": [ # Set of rules to be applied to infoTypes. The rules are applied in order.
            { # A single inspection rule to be applied to infoTypes, specified in
                # `InspectionRuleSet`.
              "hotwordRule": { # The rule that adjusts the likelihood of findings within a certain # Hotword-based detection rule.
                  # proximity of hotwords.
                "proximity": { # Message for specifying a window around a finding to apply a detection # 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.
                    # rule.
                  "windowAfter": 42, # Number of characters after the finding to consider.
                  "windowBefore": 42, # Number of characters before the finding to consider.
                },
                "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "likelihoodAdjustment": { # Message for specifying an adjustment to the likelihood of a finding as # Likelihood adjustment to apply to all matching findings.
                    # part of a detection rule.
                  "relativeLikelihood": 42, # 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`.
                  "fixedLikelihood": "A String", # Set the likelihood of a finding to a fixed value.
                },
              },
              "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                  # `InspectionRuleSet` are removed from results.
                "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                  "pattern": "A String", # Pattern defining the regular expression. Its syntax
                      # (https://github.com/google/re2/wiki/Syntax) can be found under the
                      # google/re2 repository on GitHub.
                  "groupIndexes": [ # The index of the submatch to extract as findings. When not
                      # specified, the entire match is returned. No more than 3 may be included.
                    42,
                  ],
                },
                "excludeInfoTypes": { # List of exclude infoTypes. # Set of infoTypes for which findings would affect this rule.
                  "infoTypes": [ # 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.
                    { # Type of information detected by the API.
                      "name": "A String", # 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. InfoType names should conform to the pattern
                          # [a-zA-Z0-9_]{1,64}.
                    },
                  ],
                },
                "dictionary": { # Custom information type based on a dictionary of words or phrases. This can # Dictionary which defines the rule.
                    # 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.
                  "wordList": { # Message defining a list of words or phrases to search for in the data. # List of words or phrases to search for.
                    "words": [ # 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]
                      "A String",
                    ],
                  },
                  "cloudStoragePath": { # Message representing a single file or path in Cloud Storage. # Newline-delimited file of words in Cloud Storage. Only a single file
                      # is accepted.
                    "path": "A String", # A url representing a file or path (no wildcards) in Cloud Storage.
                        # Example: gs://[BUCKET_NAME]/dictionary.txt
                  },
                },
                "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
              },
            },
          ],
          "infoTypes": [ # List of infoTypes this rule set is applied to.
            { # Type of information detected by the API.
              "name": "A String", # 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. InfoType names should conform to the pattern
                  # [a-zA-Z0-9_]{1,64}.
            },
          ],
        },
      ],
      "contentOptions": [ # List of options defining data content to scan.
          # If empty, text, images, and other content will be included.
        "A String",
      ],
      "infoTypes": [ # 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.
          #
          # The special InfoType name "ALL_BASIC" can be used to trigger all detectors,
          # but may change over time as new InfoTypes are added. If you need precise
          # control and predictability as to what detectors are run you should specify
          # specific InfoTypes listed in the reference.
        { # Type of information detected by the API.
          "name": "A String", # 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. InfoType names should conform to the pattern
              # [a-zA-Z0-9_]{1,64}.
        },
      ],
    },
    "createTime": "A String", # The creation timestamp of a inspectTemplate, output only field.
    "name": "A String", # The template name. Output only.
        #
        # The template will have one of the following formats:
        # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
        # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  }</pre>
</div>

</body></html>