# Cloud Data Loss Prevention (DLP) API . projects . locations . inspectTemplates

## Instance Methods

Creates an InspectTemplate for re-using frequently used configuration

Deletes an InspectTemplate.

Gets an InspectTemplate.

Lists InspectTemplates.

Retrieves the next page of results.

Updates the InspectTemplate.

### Method Details

`create(parent, locationId, body=None, x__xgafv=None)`

    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, Required. The parent resource name, for example projects/my-project-id or
    organizations/my-org-id. (required)
      locationId: string, The geographic location to store the inspection template. Reserved for
    future extensions. (required)
      body: object, The request body.
        The object takes the form of:

    { # Request message for CreateInspectTemplate.
        "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.
        "inspectTemplate": { # The inspectTemplate contains a configuration (set of types of sensitive data # Required. 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.
          "name": "A String", # Output only. The template name.
              #
              # The template will have one of the following formats:
              # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
              # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
          "description": "A String", # Short description (max 256 chars).
          "displayName": "A String", # Display name (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.
            "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.
            "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.
                #
                # If you need precise control and predictability as to what detectors are
                # run you should specify specific InfoTypes listed in the reference,
                # otherwise a default list will be used, which may change over time.
              { # 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}`.
              },
            ],
            "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
            "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.
                "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`.
                },
                "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.
                "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}`.
                },
                "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                  "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,
                  ],
                  "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.
                },
                "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.
                      "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.
                      },
                      "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                        "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,
                        ],
                        "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.
                      },
                      "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.
                        "windowBefore": 42, # Number of characters before the finding to consider.
                        "windowAfter": 42, # Number of characters after the finding to consider.
                      },
                    },
                  },
                ],
                "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.
                "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.
                },
              },
            ],
            "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.
                "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}`.
                  },
                ],
                "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.
                      "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.
                      },
                      "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                        "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,
                        ],
                        "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.
                      },
                      "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.
                        "windowBefore": 42, # Number of characters before the finding to consider.
                        "windowAfter": 42, # Number of characters after the finding to consider.
                      },
                    },
                    "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                        # `InspectionRuleSet` are removed from results.
                      "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
                        },
                      },
                      "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                        "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,
                        ],
                        "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.
                      },
                      "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}`.
                          },
                        ],
                      },
                      "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                    },
                  },
                ],
              },
            ],
            "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
              "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                  # When set within `InspectJobConfig`,
                  # the maximum returned is 2000 regardless if this is set higher.
                  # When set within `InspectContentRequest`, this field is ignored.
              "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
                { # Max findings configuration per infoType, per content item or long
                    # running DlpJob.
                  "maxFindings": 42, # Max findings limit for the given infoType.
                  "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}`.
                  },
                },
              ],
              "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.
            },
          },
          "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
          "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
        },
        "locationId": "A String", # The geographic location to store the inspection template. Reserved for
            # future extensions.
      }

      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.
        "name": "A String", # Output only. The template name.
            #
            # The template will have one of the following formats:
            # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
            # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
        "description": "A String", # Short description (max 256 chars).
        "displayName": "A String", # Display name (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.
          "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.
          "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.
              #
              # If you need precise control and predictability as to what detectors are
              # run you should specify specific InfoTypes listed in the reference,
              # otherwise a default list will be used, which may change over time.
            { # 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}`.
            },
          ],
          "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
          "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.
              "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`.
              },
              "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.
              "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}`.
              },
              "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                "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,
                ],
                "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.
              },
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                },
              ],
              "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.
              "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.
              },
            },
          ],
          "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.
              "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}`.
                },
              ],
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                  "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                      # `InspectionRuleSet` are removed from results.
                    "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
                      },
                    },
                    "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                      "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,
                      ],
                      "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.
                    },
                    "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}`.
                        },
                      ],
                    },
                    "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                  },
                },
              ],
            },
          ],
          "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
            "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                # When set within `InspectJobConfig`,
                # the maximum returned is 2000 regardless if this is set higher.
                # When set within `InspectContentRequest`, this field is ignored.
            "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
              { # Max findings configuration per infoType, per content item or long
                  # running DlpJob.
                "maxFindings": 42, # Max findings limit for the given infoType.
                "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}`.
                },
              },
            ],
            "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.
          },
        },
        "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
        "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
      }

`delete(name, x__xgafv=None)`

    Deletes an InspectTemplate.
    See https://cloud.google.com/dlp/docs/creating-templates to learn more.

    Args:
      name: string, Required. 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 `{}`.
      }

`get(name, x__xgafv=None)`

    Gets an InspectTemplate.
    See https://cloud.google.com/dlp/docs/creating-templates to learn more.

    Args:
      name: string, Required. 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.
        "name": "A String", # Output only. The template name.
            #
            # The template will have one of the following formats:
            # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
            # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
        "description": "A String", # Short description (max 256 chars).
        "displayName": "A String", # Display name (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.
          "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.
          "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.
              #
              # If you need precise control and predictability as to what detectors are
              # run you should specify specific InfoTypes listed in the reference,
              # otherwise a default list will be used, which may change over time.
            { # 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}`.
            },
          ],
          "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
          "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.
              "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`.
              },
              "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.
              "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}`.
              },
              "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                "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,
                ],
                "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.
              },
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                },
              ],
              "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.
              "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.
              },
            },
          ],
          "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.
              "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}`.
                },
              ],
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                  "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                      # `InspectionRuleSet` are removed from results.
                    "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
                      },
                    },
                    "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                      "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,
                      ],
                      "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.
                    },
                    "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}`.
                        },
                      ],
                    },
                    "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                  },
                },
              ],
            },
          ],
          "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
            "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                # When set within `InspectJobConfig`,
                # the maximum returned is 2000 regardless if this is set higher.
                # When set within `InspectContentRequest`, this field is ignored.
            "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
              { # Max findings configuration per infoType, per content item or long
                  # running DlpJob.
                "maxFindings": 42, # Max findings limit for the given infoType.
                "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}`.
                },
              },
            ],
            "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.
          },
        },
        "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
        "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
      }

`list(parent, locationId, orderBy=None, pageToken=None, pageSize=None, x__xgafv=None)`

    Lists InspectTemplates.
    See https://cloud.google.com/dlp/docs/creating-templates to learn more.

    Args:
      parent: string, Required. The parent resource name, for example projects/my-project-id or
    organizations/my-org-id. (required)
      locationId: string, The geographic location where inspection templates will be retrieved from.
    Use `-` for all locations. Reserved for future extensions. (required)
      orderBy: string, 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, Page token to continue retrieval. Comes from previous call
    to `ListInspectTemplates`.
      pageSize: integer, Size of the page, can be limited by server. If zero server returns
    a page of max size 100.
      x__xgafv: string, V1 error format.
        Allowed values
          1 - v1 error format
          2 - v2 error format

    Returns:
      An object of the form:

        { # Response message for ListInspectTemplates.
        "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.
            "name": "A String", # Output only. The template name.
                #
                # The template will have one of the following formats:
                # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
                # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
            "description": "A String", # Short description (max 256 chars).
            "displayName": "A String", # Display name (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.
              "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.
              "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.
                  #
                  # If you need precise control and predictability as to what detectors are
                  # run you should specify specific InfoTypes listed in the reference,
                  # otherwise a default list will be used, which may change over time.
                { # 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}`.
                },
              ],
              "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
              "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.
                  "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`.
                  },
                  "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.
                  "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}`.
                  },
                  "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                    "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,
                    ],
                    "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.
                  },
                  "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.
                        "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.
                        },
                        "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                          "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,
                          ],
                          "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.
                        },
                        "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.
                          "windowBefore": 42, # Number of characters before the finding to consider.
                          "windowAfter": 42, # Number of characters after the finding to consider.
                        },
                      },
                    },
                  ],
                  "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.
                  "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.
                  },
                },
              ],
              "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.
                  "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}`.
                    },
                  ],
                  "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.
                        "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.
                        },
                        "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                          "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,
                          ],
                          "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.
                        },
                        "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.
                          "windowBefore": 42, # Number of characters before the finding to consider.
                          "windowAfter": 42, # Number of characters after the finding to consider.
                        },
                      },
                      "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                          # `InspectionRuleSet` are removed from results.
                        "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
                          },
                        },
                        "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                          "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,
                          ],
                          "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.
                        },
                        "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}`.
                            },
                          ],
                        },
                        "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                      },
                    },
                  ],
                },
              ],
              "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
                "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                    # When set within `InspectJobConfig`,
                    # the maximum returned is 2000 regardless if this is set higher.
                    # When set within `InspectContentRequest`, this field is ignored.
                "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
                  { # Max findings configuration per infoType, per content item or long
                      # running DlpJob.
                    "maxFindings": 42, # Max findings limit for the given infoType.
                    "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}`.
                    },
                  },
                ],
                "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.
              },
            },
            "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
            "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
          },
        ],
        "nextPageToken": "A String", # If the next page is available then the next page token to be used
            # in following ListInspectTemplates request.
      }

`list_next(previous_request, previous_response)`

    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.

`patch(name, body=None, x__xgafv=None)`

    Updates the InspectTemplate.
    See https://cloud.google.com/dlp/docs/creating-templates to learn more.

    Args:
      name: string, Required. 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.
        The object takes the form of:

    { # Request message for UpdateInspectTemplate.
        "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.
          "name": "A String", # Output only. The template name.
              #
              # The template will have one of the following formats:
              # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
              # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
          "description": "A String", # Short description (max 256 chars).
          "displayName": "A String", # Display name (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.
            "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.
            "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.
                #
                # If you need precise control and predictability as to what detectors are
                # run you should specify specific InfoTypes listed in the reference,
                # otherwise a default list will be used, which may change over time.
              { # 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}`.
              },
            ],
            "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
            "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.
                "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`.
                },
                "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.
                "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}`.
                },
                "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                  "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,
                  ],
                  "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.
                },
                "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.
                      "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.
                      },
                      "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                        "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,
                        ],
                        "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.
                      },
                      "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.
                        "windowBefore": 42, # Number of characters before the finding to consider.
                        "windowAfter": 42, # Number of characters after the finding to consider.
                      },
                    },
                  },
                ],
                "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.
                "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.
                },
              },
            ],
            "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.
                "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}`.
                  },
                ],
                "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.
                      "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.
                      },
                      "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                        "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,
                        ],
                        "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.
                      },
                      "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.
                        "windowBefore": 42, # Number of characters before the finding to consider.
                        "windowAfter": 42, # Number of characters after the finding to consider.
                      },
                    },
                    "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                        # `InspectionRuleSet` are removed from results.
                      "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
                        },
                      },
                      "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                        "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,
                        ],
                        "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.
                      },
                      "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}`.
                          },
                        ],
                      },
                      "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                    },
                  },
                ],
              },
            ],
            "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
              "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                  # When set within `InspectJobConfig`,
                  # the maximum returned is 2000 regardless if this is set higher.
                  # When set within `InspectContentRequest`, this field is ignored.
              "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
                { # Max findings configuration per infoType, per content item or long
                    # running DlpJob.
                  "maxFindings": 42, # Max findings limit for the given infoType.
                  "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}`.
                  },
                },
              ],
              "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.
            },
          },
          "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
          "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
        },
        "updateMask": "A String", # Mask to control which fields get updated.
      }

      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.
        "name": "A String", # Output only. The template name.
            #
            # The template will have one of the following formats:
            # `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR
            # `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`;
        "description": "A String", # Short description (max 256 chars).
        "displayName": "A String", # Display name (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.
          "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.
          "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.
              #
              # If you need precise control and predictability as to what detectors are
              # run you should specify specific InfoTypes listed in the reference,
              # otherwise a default list will be used, which may change over time.
            { # 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}`.
            },
          ],
          "excludeInfoTypes": True or False, # When true, excludes type information of the findings.
          "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.
              "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`.
              },
              "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.
              "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}`.
              },
              "regex": { # Message defining a custom regular expression. # Regular expression based CustomInfoType.
                "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,
                ],
                "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.
              },
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                },
              ],
              "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.
              "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.
              },
            },
          ],
          "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.
              "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}`.
                },
              ],
              "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.
                    "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.
                    },
                    "hotwordRegex": { # Message defining a custom regular expression. # Regular expression pattern defining what qualifies as a hotword.
                      "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,
                      ],
                      "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.
                    },
                    "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.
                      "windowBefore": 42, # Number of characters before the finding to consider.
                      "windowAfter": 42, # Number of characters after the finding to consider.
                    },
                  },
                  "exclusionRule": { # The rule that specifies conditions when findings of infoTypes specified in # Exclusion rule.
                      # `InspectionRuleSet` are removed from results.
                    "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
                      },
                    },
                    "regex": { # Message defining a custom regular expression. # Regular expression which defines the rule.
                      "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,
                      ],
                      "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.
                    },
                    "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}`.
                        },
                      ],
                    },
                    "matchingType": "A String", # How the rule is applied, see MatchingType documentation for details.
                  },
                },
              ],
            },
          ],
          "limits": { # Configuration to control the number of findings returned. # Configuration to control the number of findings returned.
            "maxFindingsPerItem": 42, # Max number of findings that will be returned for each item scanned.
                # When set within `InspectJobConfig`,
                # the maximum returned is 2000 regardless if this is set higher.
                # When set within `InspectContentRequest`, this field is ignored.
            "maxFindingsPerInfoType": [ # Configuration of findings limit given for specified infoTypes.
              { # Max findings configuration per infoType, per content item or long
                  # running DlpJob.
                "maxFindings": 42, # Max findings limit for the given infoType.
                "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}`.
                },
              },
            ],
            "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.
          },
        },
        "createTime": "A String", # Output only. The creation timestamp of an inspectTemplate.
        "updateTime": "A String", # Output only. The last update timestamp of an inspectTemplate.
      }