# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'PreventionDeidentifyTemplateDeidentifyConfigArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs',
    'PreventionInspectTemplateInspectConfigArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs',
    'PreventionInspectTemplateInspectConfigInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigLimitsArgs',
    'PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigRuleSetArgs',
    'PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs',
    'PreventionJobTriggerInspectJobArgs',
    'PreventionJobTriggerInspectJobActionArgs',
    'PreventionJobTriggerInspectJobActionSaveFindingsArgs',
    'PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs',
    'PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs',
    'PreventionJobTriggerInspectJobStorageConfigArgs',
    'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs',
    'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs',
    'PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs',
    'PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs',
    'PreventionJobTriggerTriggerArgs',
    'PreventionJobTriggerTriggerScheduleArgs',
    'PreventionStoredInfoTypeDictionaryArgs',
    'PreventionStoredInfoTypeDictionaryCloudStoragePathArgs',
    'PreventionStoredInfoTypeDictionaryWordListArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs',
    'PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs',
    'PreventionStoredInfoTypeRegexArgs',
]

@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigArgs:
    def __init__(__self__, *,
                 info_type_transformations: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs']):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs'] info_type_transformations: Specifies free-text based transformations to be applied to the dataset.
               Structure is documented below.
        """
        pulumi.set(__self__, "info_type_transformations", info_type_transformations)

    @property
    @pulumi.getter(name="infoTypeTransformations")
    def info_type_transformations(self) -> pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs']:
        """
        Specifies free-text based transformations to be applied to the dataset.
        Structure is documented below.
        """
        return pulumi.get(self, "info_type_transformations")

    @info_type_transformations.setter
    def info_type_transformations(self, value: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs']):
        pulumi.set(self, "info_type_transformations", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs:
    def __init__(__self__, *,
                 transformations: pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs']]] transformations: Transformation for each infoType. Cannot specify more than one for a given infoType.
               Structure is documented below.
        """
        pulumi.set(__self__, "transformations", transformations)

    @property
    @pulumi.getter
    def transformations(self) -> pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs']]]:
        """
        Transformation for each infoType. Cannot specify more than one for a given infoType.
        Structure is documented below.
        """
        return pulumi.get(self, "transformations")

    @transformations.setter
    def transformations(self, value: pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs']]]):
        pulumi.set(self, "transformations", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationArgs:
    def __init__(__self__, *,
                 primitive_transformation: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs'],
                 info_types: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs']]]] = None):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs'] primitive_transformation: Primitive transformation to apply to the infoType.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs']]] info_types: InfoTypes to apply the transformation to. Leaving this empty will apply the transformation to apply to
               all findings that correspond to infoTypes that were requested in InspectConfig.
               Structure is documented below.
        """
        pulumi.set(__self__, "primitive_transformation", primitive_transformation)
        if info_types is not None:
            pulumi.set(__self__, "info_types", info_types)

    @property
    @pulumi.getter(name="primitiveTransformation")
    def primitive_transformation(self) -> pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs']:
        """
        Primitive transformation to apply to the infoType.
        Structure is documented below.
        """
        return pulumi.get(self, "primitive_transformation")

    @primitive_transformation.setter
    def primitive_transformation(self, value: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs']):
        pulumi.set(self, "primitive_transformation", value)

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs']]]]:
        """
        InfoTypes to apply the transformation to. Leaving this empty will apply the transformation to apply to
        all findings that correspond to infoTypes that were requested in InspectConfig.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

    @info_types.setter
    def info_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs']]]]):
        pulumi.set(self, "info_types", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs:
    def __init__(__self__, *,
                 character_mask_config: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs']] = None,
                 crypto_deterministic_config: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs']] = None,
                 crypto_replace_ffx_fpe_config: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs']] = None,
                 replace_config: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs']] = None,
                 replace_with_info_type_config: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs'] character_mask_config: Partially mask a string by replacing a given number of characters with a fixed character.
               Masking can start from the beginning or end of the string.
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs'] crypto_deterministic_config: Pseudonymization method that generates deterministic encryption for the given input. Outputs a base64 encoded representation of the encrypted output. Uses AES-SIV based on the RFC [https://tools.ietf.org/html/rfc5297](https://tools.ietf.org/html/rfc5297).
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs'] crypto_replace_ffx_fpe_config: Replaces an identifier with a surrogate using Format Preserving Encryption (FPE) with the FFX mode of operation; however when used in the `content.reidentify` API method, it serves the opposite function by reversing the surrogate back into the original identifier. The identifier must be encoded as ASCII. For a given crypto key and context, the same identifier will be replaced with the same surrogate. Identifiers must be at least two characters long. In the case that the identifier is the empty string, it will be skipped. See [https://cloud.google.com/dlp/docs/pseudonymization](https://cloud.google.com/dlp/docs/pseudonymization) to learn more.
               Note: We recommend using CryptoDeterministicConfig for all use cases which do not require preserving the input alphabet space and size, plus warrant referential integrity.
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs'] replace_config: Replace each input value with a given value.
               Structure is documented below.
        :param pulumi.Input[bool] replace_with_info_type_config: Replace each matching finding with the name of the info type.
        """
        if character_mask_config is not None:
            pulumi.set(__self__, "character_mask_config", character_mask_config)
        if crypto_deterministic_config is not None:
            pulumi.set(__self__, "crypto_deterministic_config", crypto_deterministic_config)
        if crypto_replace_ffx_fpe_config is not None:
            pulumi.set(__self__, "crypto_replace_ffx_fpe_config", crypto_replace_ffx_fpe_config)
        if replace_config is not None:
            pulumi.set(__self__, "replace_config", replace_config)
        if replace_with_info_type_config is not None:
            pulumi.set(__self__, "replace_with_info_type_config", replace_with_info_type_config)

    @property
    @pulumi.getter(name="characterMaskConfig")
    def character_mask_config(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs']]:
        """
        Partially mask a string by replacing a given number of characters with a fixed character.
        Masking can start from the beginning or end of the string.
        Structure is documented below.
        """
        return pulumi.get(self, "character_mask_config")

    @character_mask_config.setter
    def character_mask_config(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs']]):
        pulumi.set(self, "character_mask_config", value)

    @property
    @pulumi.getter(name="cryptoDeterministicConfig")
    def crypto_deterministic_config(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs']]:
        """
        Pseudonymization method that generates deterministic encryption for the given input. Outputs a base64 encoded representation of the encrypted output. Uses AES-SIV based on the RFC [https://tools.ietf.org/html/rfc5297](https://tools.ietf.org/html/rfc5297).
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_deterministic_config")

    @crypto_deterministic_config.setter
    def crypto_deterministic_config(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs']]):
        pulumi.set(self, "crypto_deterministic_config", value)

    @property
    @pulumi.getter(name="cryptoReplaceFfxFpeConfig")
    def crypto_replace_ffx_fpe_config(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs']]:
        """
        Replaces an identifier with a surrogate using Format Preserving Encryption (FPE) with the FFX mode of operation; however when used in the `content.reidentify` API method, it serves the opposite function by reversing the surrogate back into the original identifier. The identifier must be encoded as ASCII. For a given crypto key and context, the same identifier will be replaced with the same surrogate. Identifiers must be at least two characters long. In the case that the identifier is the empty string, it will be skipped. See [https://cloud.google.com/dlp/docs/pseudonymization](https://cloud.google.com/dlp/docs/pseudonymization) to learn more.
        Note: We recommend using CryptoDeterministicConfig for all use cases which do not require preserving the input alphabet space and size, plus warrant referential integrity.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_replace_ffx_fpe_config")

    @crypto_replace_ffx_fpe_config.setter
    def crypto_replace_ffx_fpe_config(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs']]):
        pulumi.set(self, "crypto_replace_ffx_fpe_config", value)

    @property
    @pulumi.getter(name="replaceConfig")
    def replace_config(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs']]:
        """
        Replace each input value with a given value.
        Structure is documented below.
        """
        return pulumi.get(self, "replace_config")

    @replace_config.setter
    def replace_config(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs']]):
        pulumi.set(self, "replace_config", value)

    @property
    @pulumi.getter(name="replaceWithInfoTypeConfig")
    def replace_with_info_type_config(self) -> Optional[pulumi.Input[bool]]:
        """
        Replace each matching finding with the name of the info type.
        """
        return pulumi.get(self, "replace_with_info_type_config")

    @replace_with_info_type_config.setter
    def replace_with_info_type_config(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace_with_info_type_config", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigArgs:
    def __init__(__self__, *,
                 characters_to_ignores: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs']]]] = None,
                 masking_character: Optional[pulumi.Input[str]] = None,
                 number_to_mask: Optional[pulumi.Input[int]] = None,
                 reverse_order: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs']]] characters_to_ignores: Characters to skip when doing de-identification of a value. These will be left alone and skipped.
               Structure is documented below.
        :param pulumi.Input[str] masking_character: Character to use to mask the sensitive values—for example, * for an alphabetic string such as a name, or 0 for a numeric string
               such as ZIP code or credit card number. This string must have a length of 1. If not supplied, this value defaults to * for
               strings, and 0 for digits.
        :param pulumi.Input[int] number_to_mask: Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.
        :param pulumi.Input[bool] reverse_order: Mask characters in reverse order. For example, if masking_character is 0, number_to_mask is 14, and reverse_order is `false`, then the
               input string `1234-5678-9012-3456` is masked as `00000000000000-3456`.
        """
        if characters_to_ignores is not None:
            pulumi.set(__self__, "characters_to_ignores", characters_to_ignores)
        if masking_character is not None:
            pulumi.set(__self__, "masking_character", masking_character)
        if number_to_mask is not None:
            pulumi.set(__self__, "number_to_mask", number_to_mask)
        if reverse_order is not None:
            pulumi.set(__self__, "reverse_order", reverse_order)

    @property
    @pulumi.getter(name="charactersToIgnores")
    def characters_to_ignores(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs']]]]:
        """
        Characters to skip when doing de-identification of a value. These will be left alone and skipped.
        Structure is documented below.
        """
        return pulumi.get(self, "characters_to_ignores")

    @characters_to_ignores.setter
    def characters_to_ignores(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs']]]]):
        pulumi.set(self, "characters_to_ignores", value)

    @property
    @pulumi.getter(name="maskingCharacter")
    def masking_character(self) -> Optional[pulumi.Input[str]]:
        """
        Character to use to mask the sensitive values—for example, * for an alphabetic string such as a name, or 0 for a numeric string
        such as ZIP code or credit card number. This string must have a length of 1. If not supplied, this value defaults to * for
        strings, and 0 for digits.
        """
        return pulumi.get(self, "masking_character")

    @masking_character.setter
    def masking_character(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "masking_character", value)

    @property
    @pulumi.getter(name="numberToMask")
    def number_to_mask(self) -> Optional[pulumi.Input[int]]:
        """
        Number of characters to mask. If not set, all matching chars will be masked. Skipped characters do not count towards this tally.
        """
        return pulumi.get(self, "number_to_mask")

    @number_to_mask.setter
    def number_to_mask(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "number_to_mask", value)

    @property
    @pulumi.getter(name="reverseOrder")
    def reverse_order(self) -> Optional[pulumi.Input[bool]]:
        """
        Mask characters in reverse order. For example, if masking_character is 0, number_to_mask is 14, and reverse_order is `false`, then the
        input string `1234-5678-9012-3456` is masked as `00000000000000-3456`.
        """
        return pulumi.get(self, "reverse_order")

    @reverse_order.setter
    def reverse_order(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "reverse_order", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs:
    def __init__(__self__, *,
                 characters_to_skip: Optional[pulumi.Input[str]] = None,
                 common_characters_to_ignore: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] characters_to_skip: Characters to not transform when masking.
        :param pulumi.Input[str] common_characters_to_ignore: Common characters to not transform when masking. Useful to avoid removing punctuation.
               Possible values are `NUMERIC`, `ALPHA_UPPER_CASE`, `ALPHA_LOWER_CASE`, `PUNCTUATION`, and `WHITESPACE`.
        """
        if characters_to_skip is not None:
            pulumi.set(__self__, "characters_to_skip", characters_to_skip)
        if common_characters_to_ignore is not None:
            pulumi.set(__self__, "common_characters_to_ignore", common_characters_to_ignore)

    @property
    @pulumi.getter(name="charactersToSkip")
    def characters_to_skip(self) -> Optional[pulumi.Input[str]]:
        """
        Characters to not transform when masking.
        """
        return pulumi.get(self, "characters_to_skip")

    @characters_to_skip.setter
    def characters_to_skip(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "characters_to_skip", value)

    @property
    @pulumi.getter(name="commonCharactersToIgnore")
    def common_characters_to_ignore(self) -> Optional[pulumi.Input[str]]:
        """
        Common characters to not transform when masking. Useful to avoid removing punctuation.
        Possible values are `NUMERIC`, `ALPHA_UPPER_CASE`, `ALPHA_LOWER_CASE`, `PUNCTUATION`, and `WHITESPACE`.
        """
        return pulumi.get(self, "common_characters_to_ignore")

    @common_characters_to_ignore.setter
    def common_characters_to_ignore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "common_characters_to_ignore", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigArgs:
    def __init__(__self__, *,
                 context: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs']] = None,
                 crypto_key: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs']] = None,
                 surrogate_info_type: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs']] = None):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs'] context: The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. If the context is not set, a default tweak will be used.
               If the context is set but:
               1.  there is no record present when transforming a given value or
               2.  the field is not present when transforming a given value,
               a default tweak will be used.
               Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s. Currently, the referenced field may be of value type integer or string.
               The tweak is constructed as a sequence of bytes in big endian byte order such that:
               *   a 64 bit integer is encoded followed by a single byte of value 1
               *   a string is encoded in UTF-8 format followed by a single byte of value 2
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs'] crypto_key: The key used by the encryption algorithm.
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs'] surrogate_info_type: The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info\\_type\\_name(surrogate\\_character\\_count):surrogate
               For example, if the name of custom infoType is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
               This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text.
               In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE
               Structure is documented below.
        """
        if context is not None:
            pulumi.set(__self__, "context", context)
        if crypto_key is not None:
            pulumi.set(__self__, "crypto_key", crypto_key)
        if surrogate_info_type is not None:
            pulumi.set(__self__, "surrogate_info_type", surrogate_info_type)

    @property
    @pulumi.getter
    def context(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs']]:
        """
        The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. If the context is not set, a default tweak will be used.
        If the context is set but:
        1.  there is no record present when transforming a given value or
        2.  the field is not present when transforming a given value,
        a default tweak will be used.
        Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s. Currently, the referenced field may be of value type integer or string.
        The tweak is constructed as a sequence of bytes in big endian byte order such that:
        *   a 64 bit integer is encoded followed by a single byte of value 1
        *   a string is encoded in UTF-8 format followed by a single byte of value 2
        Structure is documented below.
        """
        return pulumi.get(self, "context")

    @context.setter
    def context(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs']]):
        pulumi.set(self, "context", value)

    @property
    @pulumi.getter(name="cryptoKey")
    def crypto_key(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs']]:
        """
        The key used by the encryption algorithm.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_key")

    @crypto_key.setter
    def crypto_key(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs']]):
        pulumi.set(self, "crypto_key", value)

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs']]:
        """
        The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info\\_type\\_name(surrogate\\_character\\_count):surrogate
        For example, if the name of custom infoType is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
        This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text.
        In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE
        Structure is documented below.
        """
        return pulumi.get(self, "surrogate_info_type")

    @surrogate_info_type.setter
    def surrogate_info_type(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs']]):
        pulumi.set(self, "surrogate_info_type", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs:
    def __init__(__self__, *,
                 kms_wrapped: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs']] = None,
                 transient: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs']] = None,
                 unwrapped: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs']] = None):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs'] kms_wrapped: Kms wrapped key
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs'] transient: Transient crypto key
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs'] unwrapped: Unwrapped crypto key
               Structure is documented below.
        """
        if kms_wrapped is not None:
            pulumi.set(__self__, "kms_wrapped", kms_wrapped)
        if transient is not None:
            pulumi.set(__self__, "transient", transient)
        if unwrapped is not None:
            pulumi.set(__self__, "unwrapped", unwrapped)

    @property
    @pulumi.getter(name="kmsWrapped")
    def kms_wrapped(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs']]:
        """
        Kms wrapped key
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @kms_wrapped.setter
    def kms_wrapped(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs']]):
        pulumi.set(self, "kms_wrapped", value)

    @property
    @pulumi.getter
    def transient(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs']]:
        """
        Transient crypto key
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @transient.setter
    def transient(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs']]):
        pulumi.set(self, "transient", value)

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs']]:
        """
        Unwrapped crypto key
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")

    @unwrapped.setter
    def unwrapped(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs']]):
        pulumi.set(self, "unwrapped", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs:
    def __init__(__self__, *,
                 crypto_key_name: pulumi.Input[str],
                 wrapped_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param pulumi.Input[str] wrapped_key: The wrapped data crypto key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "crypto_key_name", crypto_key_name)
        pulumi.set(__self__, "wrapped_key", wrapped_key)

    @property
    @pulumi.getter(name="cryptoKeyName")
    def crypto_key_name(self) -> pulumi.Input[str]:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

    @crypto_key_name.setter
    def crypto_key_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "crypto_key_name", value)

    @property
    @pulumi.getter(name="wrappedKey")
    def wrapped_key(self) -> pulumi.Input[str]:
        """
        The wrapped data crypto key.
        A base64-encoded string.
        """
        return pulumi.get(self, "wrapped_key")

    @wrapped_key.setter
    def wrapped_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "wrapped_key", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        A 128/192/256 bit key.
        A base64-encoded string.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs:
    def __init__(__self__, *,
                 common_alphabet: Optional[pulumi.Input[str]] = None,
                 context: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs']] = None,
                 crypto_key: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs']] = None,
                 custom_alphabet: Optional[pulumi.Input[str]] = None,
                 radix: Optional[pulumi.Input[int]] = None,
                 surrogate_info_type: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs']] = None):
        """
        :param pulumi.Input[str] common_alphabet: Common alphabets.
               Possible values are `FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED`, `NUMERIC`, `HEXADECIMAL`, `UPPER_CASE_ALPHA_NUMERIC`, and `ALPHA_NUMERIC`.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs'] context: The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. If the context is not set, a default tweak will be used.
               If the context is set but:
               1.  there is no record present when transforming a given value or
               2.  the field is not present when transforming a given value,
               a default tweak will be used.
               Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s. Currently, the referenced field may be of value type integer or string.
               The tweak is constructed as a sequence of bytes in big endian byte order such that:
               *   a 64 bit integer is encoded followed by a single byte of value 1
               *   a string is encoded in UTF-8 format followed by a single byte of value 2
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs'] crypto_key: The key used by the encryption algorithm.
               Structure is documented below.
        :param pulumi.Input[str] custom_alphabet: This is supported by mapping these to the alphanumeric characters that the FFX mode natively supports. This happens before/after encryption/decryption. Each character listed must appear only once. Number of characters must be in the range \\[2, 95\\]. This must be encoded as ASCII. The order of characters does not matter. The full list of allowed characters is:
               ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ~`!@#$%^&*()_-+={[}]|:;"'<,>.?/``
        :param pulumi.Input[int] radix: The native way to select the alphabet. Must be in the range \\[2, 95\\].
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs'] surrogate_info_type: The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info\\_type\\_name(surrogate\\_character\\_count):surrogate
               For example, if the name of custom infoType is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
               This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text.
               In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE
               Structure is documented below.
        """
        if common_alphabet is not None:
            pulumi.set(__self__, "common_alphabet", common_alphabet)
        if context is not None:
            pulumi.set(__self__, "context", context)
        if crypto_key is not None:
            pulumi.set(__self__, "crypto_key", crypto_key)
        if custom_alphabet is not None:
            pulumi.set(__self__, "custom_alphabet", custom_alphabet)
        if radix is not None:
            pulumi.set(__self__, "radix", radix)
        if surrogate_info_type is not None:
            pulumi.set(__self__, "surrogate_info_type", surrogate_info_type)

    @property
    @pulumi.getter(name="commonAlphabet")
    def common_alphabet(self) -> Optional[pulumi.Input[str]]:
        """
        Common alphabets.
        Possible values are `FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED`, `NUMERIC`, `HEXADECIMAL`, `UPPER_CASE_ALPHA_NUMERIC`, and `ALPHA_NUMERIC`.
        """
        return pulumi.get(self, "common_alphabet")

    @common_alphabet.setter
    def common_alphabet(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "common_alphabet", value)

    @property
    @pulumi.getter
    def context(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs']]:
        """
        The 'tweak', a context may be used for higher security since the same identifier in two different contexts won't be given the same surrogate. If the context is not set, a default tweak will be used.
        If the context is set but:
        1.  there is no record present when transforming a given value or
        2.  the field is not present when transforming a given value,
        a default tweak will be used.
        Note that case (1) is expected when an `InfoTypeTransformation` is applied to both structured and non-structured `ContentItem`s. Currently, the referenced field may be of value type integer or string.
        The tweak is constructed as a sequence of bytes in big endian byte order such that:
        *   a 64 bit integer is encoded followed by a single byte of value 1
        *   a string is encoded in UTF-8 format followed by a single byte of value 2
        Structure is documented below.
        """
        return pulumi.get(self, "context")

    @context.setter
    def context(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs']]):
        pulumi.set(self, "context", value)

    @property
    @pulumi.getter(name="cryptoKey")
    def crypto_key(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs']]:
        """
        The key used by the encryption algorithm.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_key")

    @crypto_key.setter
    def crypto_key(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs']]):
        pulumi.set(self, "crypto_key", value)

    @property
    @pulumi.getter(name="customAlphabet")
    def custom_alphabet(self) -> Optional[pulumi.Input[str]]:
        """
        This is supported by mapping these to the alphanumeric characters that the FFX mode natively supports. This happens before/after encryption/decryption. Each character listed must appear only once. Number of characters must be in the range \\[2, 95\\]. This must be encoded as ASCII. The order of characters does not matter. The full list of allowed characters is:
        ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ~`!@#$%^&*()_-+={[}]|:;"'<,>.?/``
        """
        return pulumi.get(self, "custom_alphabet")

    @custom_alphabet.setter
    def custom_alphabet(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_alphabet", value)

    @property
    @pulumi.getter
    def radix(self) -> Optional[pulumi.Input[int]]:
        """
        The native way to select the alphabet. Must be in the range \\[2, 95\\].
        """
        return pulumi.get(self, "radix")

    @radix.setter
    def radix(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "radix", value)

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs']]:
        """
        The custom infoType to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom infoType followed by the number of characters comprising the surrogate. The following scheme defines the format: info\\_type\\_name(surrogate\\_character\\_count):surrogate
        For example, if the name of custom infoType is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
        This annotation identifies the surrogate when inspecting content using the custom infoType [`SurrogateType`](https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#surrogatetype). This facilitates reversal of the surrogate when it occurs in free text.
        In order for inspection to work properly, the name of this infoType must not occur naturally anywhere in your data; otherwise, inspection may find a surrogate that does not correspond to an actual identifier. Therefore, choose your custom infoType name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE
        Structure is documented below.
        """
        return pulumi.get(self, "surrogate_info_type")

    @surrogate_info_type.setter
    def surrogate_info_type(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs']]):
        pulumi.set(self, "surrogate_info_type", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs:
    def __init__(__self__, *,
                 kms_wrapped: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs']] = None,
                 transient: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs']] = None,
                 unwrapped: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs']] = None):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs'] kms_wrapped: Kms wrapped key
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs'] transient: Transient crypto key
               Structure is documented below.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs'] unwrapped: Unwrapped crypto key
               Structure is documented below.
        """
        if kms_wrapped is not None:
            pulumi.set(__self__, "kms_wrapped", kms_wrapped)
        if transient is not None:
            pulumi.set(__self__, "transient", transient)
        if unwrapped is not None:
            pulumi.set(__self__, "unwrapped", unwrapped)

    @property
    @pulumi.getter(name="kmsWrapped")
    def kms_wrapped(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs']]:
        """
        Kms wrapped key
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @kms_wrapped.setter
    def kms_wrapped(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs']]):
        pulumi.set(self, "kms_wrapped", value)

    @property
    @pulumi.getter
    def transient(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs']]:
        """
        Transient crypto key
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @transient.setter
    def transient(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs']]):
        pulumi.set(self, "transient", value)

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs']]:
        """
        Unwrapped crypto key
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")

    @unwrapped.setter
    def unwrapped(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs']]):
        pulumi.set(self, "unwrapped", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs:
    def __init__(__self__, *,
                 crypto_key_name: pulumi.Input[str],
                 wrapped_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param pulumi.Input[str] wrapped_key: The wrapped data crypto key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "crypto_key_name", crypto_key_name)
        pulumi.set(__self__, "wrapped_key", wrapped_key)

    @property
    @pulumi.getter(name="cryptoKeyName")
    def crypto_key_name(self) -> pulumi.Input[str]:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

    @crypto_key_name.setter
    def crypto_key_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "crypto_key_name", value)

    @property
    @pulumi.getter(name="wrappedKey")
    def wrapped_key(self) -> pulumi.Input[str]:
        """
        The wrapped data crypto key.
        A base64-encoded string.
        """
        return pulumi.get(self, "wrapped_key")

    @wrapped_key.setter
    def wrapped_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "wrapped_key", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        A 128/192/256 bit key.
        A base64-encoded string.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: 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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        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](https://cloud.google.com/dlp/docs/infotypes-reference) when specifying a built-in type. When sending Cloud DLP results to Data Catalog, infoType names should conform to the pattern `[A-Za-z0-9$-_]{1,64}`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs:
    def __init__(__self__, *,
                 new_value: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs']):
        """
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs'] new_value: Replace each input value with a given value.
               Structure is documented below.
        """
        pulumi.set(__self__, "new_value", new_value)

    @property
    @pulumi.getter(name="newValue")
    def new_value(self) -> pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs']:
        """
        Replace each input value with a given value.
        Structure is documented below.
        """
        return pulumi.get(self, "new_value")

    @new_value.setter
    def new_value(self, value: pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs']):
        pulumi.set(self, "new_value", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs:
    def __init__(__self__, *,
                 boolean_value: Optional[pulumi.Input[bool]] = None,
                 date_value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs']] = None,
                 day_of_week_value: Optional[pulumi.Input[str]] = None,
                 float_value: Optional[pulumi.Input[float]] = None,
                 integer_value: Optional[pulumi.Input[int]] = None,
                 string_value: Optional[pulumi.Input[str]] = None,
                 time_value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs']] = None,
                 timestamp_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] boolean_value: A boolean value.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs'] date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param pulumi.Input[str] day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param pulumi.Input[float] float_value: A float value.
        :param pulumi.Input[int] integer_value: An integer value.
        :param pulumi.Input[str] string_value: A string value.
        :param pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs'] time_value: Represents a time of day.
               Structure is documented below.
        :param pulumi.Input[str] timestamp_value: A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
               Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        """
        if boolean_value is not None:
            pulumi.set(__self__, "boolean_value", boolean_value)
        if date_value is not None:
            pulumi.set(__self__, "date_value", date_value)
        if day_of_week_value is not None:
            pulumi.set(__self__, "day_of_week_value", day_of_week_value)
        if float_value is not None:
            pulumi.set(__self__, "float_value", float_value)
        if integer_value is not None:
            pulumi.set(__self__, "integer_value", integer_value)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)
        if time_value is not None:
            pulumi.set(__self__, "time_value", time_value)
        if timestamp_value is not None:
            pulumi.set(__self__, "timestamp_value", timestamp_value)

    @property
    @pulumi.getter(name="booleanValue")
    def boolean_value(self) -> Optional[pulumi.Input[bool]]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

    @boolean_value.setter
    def boolean_value(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "boolean_value", value)

    @property
    @pulumi.getter(name="dateValue")
    def date_value(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs']]:
        """
        Represents a whole or partial calendar date.
        Structure is documented below.
        """
        return pulumi.get(self, "date_value")

    @date_value.setter
    def date_value(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs']]):
        pulumi.set(self, "date_value", value)

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[pulumi.Input[str]]:
        """
        Represents a day of the week.
        Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        """
        return pulumi.get(self, "day_of_week_value")

    @day_of_week_value.setter
    def day_of_week_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "day_of_week_value", value)

    @property
    @pulumi.getter(name="floatValue")
    def float_value(self) -> Optional[pulumi.Input[float]]:
        """
        A float value.
        """
        return pulumi.get(self, "float_value")

    @float_value.setter
    def float_value(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "float_value", value)

    @property
    @pulumi.getter(name="integerValue")
    def integer_value(self) -> Optional[pulumi.Input[int]]:
        """
        An integer value.
        """
        return pulumi.get(self, "integer_value")

    @integer_value.setter
    def integer_value(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "integer_value", value)

    @property
    @pulumi.getter(name="stringValue")
    def string_value(self) -> Optional[pulumi.Input[str]]:
        """
        A string value.
        """
        return pulumi.get(self, "string_value")

    @string_value.setter
    def string_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "string_value", value)

    @property
    @pulumi.getter(name="timeValue")
    def time_value(self) -> Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs']]:
        """
        Represents a time of day.
        Structure is documented below.
        """
        return pulumi.get(self, "time_value")

    @time_value.setter
    def time_value(self, value: Optional[pulumi.Input['PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs']]):
        pulumi.set(self, "time_value", value)

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[pulumi.Input[str]]:
        """
        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        """
        return pulumi.get(self, "timestamp_value")

    @timestamp_value.setter
    def timestamp_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timestamp_value", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs:
    def __init__(__self__, *,
                 day: Optional[pulumi.Input[int]] = None,
                 month: Optional[pulumi.Input[int]] = None,
                 year: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] day: Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a
               year by itself or a year and month where the day is not significant.
        :param pulumi.Input[int] month: Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
        :param pulumi.Input[int] year: Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
        """
        if day is not None:
            pulumi.set(__self__, "day", day)
        if month is not None:
            pulumi.set(__self__, "month", month)
        if year is not None:
            pulumi.set(__self__, "year", year)

    @property
    @pulumi.getter
    def day(self) -> Optional[pulumi.Input[int]]:
        """
        Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if specifying a
        year by itself or a year and month where the day is not significant.
        """
        return pulumi.get(self, "day")

    @day.setter
    def day(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "day", value)

    @property
    @pulumi.getter
    def month(self) -> Optional[pulumi.Input[int]]:
        """
        Month of year. Must be from 1 to 12, or 0 if specifying a year without a month and day.
        """
        return pulumi.get(self, "month")

    @month.setter
    def month(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "month", value)

    @property
    @pulumi.getter
    def year(self) -> Optional[pulumi.Input[int]]:
        """
        Year of date. Must be from 1 to 9999, or 0 if specifying a date without a year.
        """
        return pulumi.get(self, "year")

    @year.setter
    def year(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "year", value)


@pulumi.input_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs:
    def __init__(__self__, *,
                 hours: Optional[pulumi.Input[int]] = None,
                 minutes: Optional[pulumi.Input[int]] = None,
                 nanos: Optional[pulumi.Input[int]] = None,
                 seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] hours: Hours of day in 24 hour format. Should be from 0 to 23.
        :param pulumi.Input[int] minutes: Minutes of hour of day. Must be from 0 to 59.
        :param pulumi.Input[int] nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param pulumi.Input[int] seconds: Seconds of minutes of the time. Must normally be from 0 to 59.
        """
        if hours is not None:
            pulumi.set(__self__, "hours", hours)
        if minutes is not None:
            pulumi.set(__self__, "minutes", minutes)
        if nanos is not None:
            pulumi.set(__self__, "nanos", nanos)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)

    @property
    @pulumi.getter
    def hours(self) -> Optional[pulumi.Input[int]]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23.
        """
        return pulumi.get(self, "hours")

    @hours.setter
    def hours(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "hours", value)

    @property
    @pulumi.getter
    def minutes(self) -> Optional[pulumi.Input[int]]:
        """
        Minutes of hour of day. Must be from 0 to 59.
        """
        return pulumi.get(self, "minutes")

    @minutes.setter
    def minutes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "minutes", value)

    @property
    @pulumi.getter
    def nanos(self) -> Optional[pulumi.Input[int]]:
        """
        Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        """
        return pulumi.get(self, "nanos")

    @nanos.setter
    def nanos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "nanos", value)

    @property
    @pulumi.getter
    def seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59.
        """
        return pulumi.get(self, "seconds")

    @seconds.setter
    def seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "seconds", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigArgs:
    def __init__(__self__, *,
                 content_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 custom_info_types: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeArgs']]]] = None,
                 exclude_info_types: Optional[pulumi.Input[bool]] = None,
                 include_quote: Optional[pulumi.Input[bool]] = None,
                 info_types: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigInfoTypeArgs']]]] = None,
                 limits: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsArgs']] = None,
                 min_likelihood: Optional[pulumi.Input[str]] = None,
                 rule_sets: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] content_options: List of options defining data content to scan. If empty, text, images, and other content will be included.
               Each value may be one of `CONTENT_TEXT` and `CONTENT_IMAGE`.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeArgs']]] custom_info_types: Custom info types to be used. See https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
               Structure is documented below.
        :param pulumi.Input[bool] exclude_info_types: Set of infoTypes for which findings would affect this rule.
               Structure is documented below.
        :param pulumi.Input[bool] include_quote: When true, a contextual quote from the data that triggered a finding is included in the response.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigInfoTypeArgs']]] info_types: If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigLimitsArgs'] limits: Configuration to control the number of findings returned.
               Structure is documented below.
        :param pulumi.Input[str] min_likelihood: Only returns findings equal or above this threshold. See https://cloud.google.com/dlp/docs/likelihood for more info
               Default value is `POSSIBLE`.
               Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetArgs']]] rule_sets: 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.
               Structure is documented below.
        """
        if content_options is not None:
            pulumi.set(__self__, "content_options", content_options)
        if custom_info_types is not None:
            pulumi.set(__self__, "custom_info_types", custom_info_types)
        if exclude_info_types is not None:
            pulumi.set(__self__, "exclude_info_types", exclude_info_types)
        if include_quote is not None:
            pulumi.set(__self__, "include_quote", include_quote)
        if info_types is not None:
            pulumi.set(__self__, "info_types", info_types)
        if limits is not None:
            pulumi.set(__self__, "limits", limits)
        if min_likelihood is not None:
            pulumi.set(__self__, "min_likelihood", min_likelihood)
        if rule_sets is not None:
            pulumi.set(__self__, "rule_sets", rule_sets)

    @property
    @pulumi.getter(name="contentOptions")
    def content_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of options defining data content to scan. If empty, text, images, and other content will be included.
        Each value may be one of `CONTENT_TEXT` and `CONTENT_IMAGE`.
        """
        return pulumi.get(self, "content_options")

    @content_options.setter
    def content_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "content_options", value)

    @property
    @pulumi.getter(name="customInfoTypes")
    def custom_info_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeArgs']]]]:
        """
        Custom info types to be used. See https://cloud.google.com/dlp/docs/creating-custom-infotypes to learn more.
        Structure is documented below.
        """
        return pulumi.get(self, "custom_info_types")

    @custom_info_types.setter
    def custom_info_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeArgs']]]]):
        pulumi.set(self, "custom_info_types", value)

    @property
    @pulumi.getter(name="excludeInfoTypes")
    def exclude_info_types(self) -> Optional[pulumi.Input[bool]]:
        """
        Set of infoTypes for which findings would affect this rule.
        Structure is documented below.
        """
        return pulumi.get(self, "exclude_info_types")

    @exclude_info_types.setter
    def exclude_info_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "exclude_info_types", value)

    @property
    @pulumi.getter(name="includeQuote")
    def include_quote(self) -> Optional[pulumi.Input[bool]]:
        """
        When true, a contextual quote from the data that triggered a finding is included in the response.
        """
        return pulumi.get(self, "include_quote")

    @include_quote.setter
    def include_quote(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_quote", value)

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigInfoTypeArgs']]]]:
        """
        If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

    @info_types.setter
    def info_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigInfoTypeArgs']]]]):
        pulumi.set(self, "info_types", value)

    @property
    @pulumi.getter
    def limits(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsArgs']]:
        """
        Configuration to control the number of findings returned.
        Structure is documented below.
        """
        return pulumi.get(self, "limits")

    @limits.setter
    def limits(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsArgs']]):
        pulumi.set(self, "limits", value)

    @property
    @pulumi.getter(name="minLikelihood")
    def min_likelihood(self) -> Optional[pulumi.Input[str]]:
        """
        Only returns findings equal or above this threshold. See https://cloud.google.com/dlp/docs/likelihood for more info
        Default value is `POSSIBLE`.
        Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        """
        return pulumi.get(self, "min_likelihood")

    @min_likelihood.setter
    def min_likelihood(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "min_likelihood", value)

    @property
    @pulumi.getter(name="ruleSets")
    def rule_sets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetArgs']]]]:
        """
        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.
        Structure is documented below.
        """
        return pulumi.get(self, "rule_sets")

    @rule_sets.setter
    def rule_sets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetArgs']]]]):
        pulumi.set(self, "rule_sets", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeArgs:
    def __init__(__self__, *,
                 info_type: pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs'],
                 dictionary: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs']] = None,
                 exclusion_type: Optional[pulumi.Input[str]] = None,
                 likelihood: Optional[pulumi.Input[str]] = None,
                 regex: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs']] = None,
                 stored_type: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs']] = None):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs'] info_type: 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 `info_types` field. Specifying the latter adds findings to the
               one detected by the system. If built-in info type is not specified in `info_types` list then the name is
               treated as a custom info type.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs'] dictionary: Dictionary which defines the rule.
               Structure is documented below.
        :param pulumi.Input[str] exclusion_type: If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding to be returned. It still can be used for rules matching.
               Possible values are `EXCLUSION_TYPE_EXCLUDE`.
        :param pulumi.Input[str] likelihood: 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.
               Default value is `VERY_LIKELY`.
               Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs'] regex: Regular expression which defines the rule.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs'] stored_type: A reference to a StoredInfoType to use with scanning.
               Structure is documented below.
        """
        pulumi.set(__self__, "info_type", info_type)
        if dictionary is not None:
            pulumi.set(__self__, "dictionary", dictionary)
        if exclusion_type is not None:
            pulumi.set(__self__, "exclusion_type", exclusion_type)
        if likelihood is not None:
            pulumi.set(__self__, "likelihood", likelihood)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)
        if stored_type is not None:
            pulumi.set(__self__, "stored_type", stored_type)

    @property
    @pulumi.getter(name="infoType")
    def info_type(self) -> pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs']:
        """
        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 `info_types` field. Specifying the latter adds findings to the
        one detected by the system. If built-in info type is not specified in `info_types` list then the name is
        treated as a custom info type.
        Structure is documented below.
        """
        return pulumi.get(self, "info_type")

    @info_type.setter
    def info_type(self, value: pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs']):
        pulumi.set(self, "info_type", value)

    @property
    @pulumi.getter
    def dictionary(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs']]:
        """
        Dictionary which defines the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "dictionary")

    @dictionary.setter
    def dictionary(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs']]):
        pulumi.set(self, "dictionary", value)

    @property
    @pulumi.getter(name="exclusionType")
    def exclusion_type(self) -> Optional[pulumi.Input[str]]:
        """
        If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding to be returned. It still can be used for rules matching.
        Possible values are `EXCLUSION_TYPE_EXCLUDE`.
        """
        return pulumi.get(self, "exclusion_type")

    @exclusion_type.setter
    def exclusion_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exclusion_type", value)

    @property
    @pulumi.getter
    def likelihood(self) -> Optional[pulumi.Input[str]]:
        """
        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.
        Default value is `VERY_LIKELY`.
        Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        """
        return pulumi.get(self, "likelihood")

    @likelihood.setter
    def likelihood(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "likelihood", value)

    @property
    @pulumi.getter
    def regex(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs']]:
        """
        Regular expression which defines the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "regex")

    @regex.setter
    def regex(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs']]):
        pulumi.set(self, "regex", value)

    @property
    @pulumi.getter(name="storedType")
    def stored_type(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs']]:
        """
        A reference to a StoredInfoType to use with scanning.
        Structure is documented below.
        """
        return pulumi.get(self, "stored_type")

    @stored_type.setter
    def stored_type(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs']]):
        pulumi.set(self, "stored_type", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs:
    def __init__(__self__, *,
                 cloud_storage_path: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs']] = None,
                 word_list: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs']] = None):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs'] cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs'] word_list: List of words or phrases to search for.
               Structure is documented below.
        """
        if cloud_storage_path is not None:
            pulumi.set(__self__, "cloud_storage_path", cloud_storage_path)
        if word_list is not None:
            pulumi.set(__self__, "word_list", word_list)

    @property
    @pulumi.getter(name="cloudStoragePath")
    def cloud_storage_path(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs']]:
        """
        Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
        Structure is documented below.
        """
        return pulumi.get(self, "cloud_storage_path")

    @cloud_storage_path.setter
    def cloud_storage_path(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs']]):
        pulumi.set(self, "cloud_storage_path", value)

    @property
    @pulumi.getter(name="wordList")
    def word_list(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs']]:
        """
        List of words or phrases to search for.
        Structure is documented below.
        """
        return pulumi.get(self, "word_list")

    @word_list.setter
    def word_list(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs']]):
        pulumi.set(self, "word_list", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        """
        :param pulumi.Input[str] path: A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordListArgs:
    def __init__(__self__, *,
                 words: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] 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.
        """
        pulumi.set(__self__, "words", words)

    @property
    @pulumi.getter
    def words(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        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.
        """
        return pulumi.get(self, "words")

    @words.setter
    def words(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "words", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs:
    def __init__(__self__, *,
                 pattern: pulumi.Input[str],
                 group_indexes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input[str] pattern: Pattern defining the regular expression.
               Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] group_indexes: The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        pulumi.set(__self__, "pattern", pattern)
        if group_indexes is not None:
            pulumi.set(__self__, "group_indexes", group_indexes)

    @property
    @pulumi.getter
    def pattern(self) -> pulumi.Input[str]:
        """
        Pattern defining the regular expression.
        Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        """
        return pulumi.get(self, "pattern")

    @pattern.setter
    def pattern(self, value: pulumi.Input[str]):
        pulumi.set(self, "pattern", value)

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        return pulumi.get(self, "group_indexes")

    @group_indexes.setter
    def group_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "group_indexes", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeStoredTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigLimitsArgs:
    def __init__(__self__, *,
                 max_findings_per_item: pulumi.Input[int],
                 max_findings_per_request: pulumi.Input[int],
                 max_findings_per_info_types: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs']]]] = None):
        """
        :param pulumi.Input[int] max_findings_per_item: Max number of findings that will be returned for each item scanned. The maximum returned is 2000.
        :param pulumi.Input[int] max_findings_per_request: Max number of findings that will be returned per request/job. The maximum returned is 2000.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs']]] max_findings_per_info_types: Configuration of findings limit given for specified infoTypes.
               Structure is documented below.
        """
        pulumi.set(__self__, "max_findings_per_item", max_findings_per_item)
        pulumi.set(__self__, "max_findings_per_request", max_findings_per_request)
        if max_findings_per_info_types is not None:
            pulumi.set(__self__, "max_findings_per_info_types", max_findings_per_info_types)

    @property
    @pulumi.getter(name="maxFindingsPerItem")
    def max_findings_per_item(self) -> pulumi.Input[int]:
        """
        Max number of findings that will be returned for each item scanned. The maximum returned is 2000.
        """
        return pulumi.get(self, "max_findings_per_item")

    @max_findings_per_item.setter
    def max_findings_per_item(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_findings_per_item", value)

    @property
    @pulumi.getter(name="maxFindingsPerRequest")
    def max_findings_per_request(self) -> pulumi.Input[int]:
        """
        Max number of findings that will be returned per request/job. The maximum returned is 2000.
        """
        return pulumi.get(self, "max_findings_per_request")

    @max_findings_per_request.setter
    def max_findings_per_request(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_findings_per_request", value)

    @property
    @pulumi.getter(name="maxFindingsPerInfoTypes")
    def max_findings_per_info_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs']]]]:
        """
        Configuration of findings limit given for specified infoTypes.
        Structure is documented below.
        """
        return pulumi.get(self, "max_findings_per_info_types")

    @max_findings_per_info_types.setter
    def max_findings_per_info_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs']]]]):
        pulumi.set(self, "max_findings_per_info_types", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeArgs:
    def __init__(__self__, *,
                 info_type: pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs'],
                 max_findings: pulumi.Input[int]):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs'] info_type: 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 `info_types` field. Specifying the latter adds findings to the
               one detected by the system. If built-in info type is not specified in `info_types` list then the name is
               treated as a custom info type.
               Structure is documented below.
        :param pulumi.Input[int] max_findings: Max findings limit for the given infoType.
        """
        pulumi.set(__self__, "info_type", info_type)
        pulumi.set(__self__, "max_findings", max_findings)

    @property
    @pulumi.getter(name="infoType")
    def info_type(self) -> pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs']:
        """
        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 `info_types` field. Specifying the latter adds findings to the
        one detected by the system. If built-in info type is not specified in `info_types` list then the name is
        treated as a custom info type.
        Structure is documented below.
        """
        return pulumi.get(self, "info_type")

    @info_type.setter
    def info_type(self, value: pulumi.Input['PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs']):
        pulumi.set(self, "info_type", value)

    @property
    @pulumi.getter(name="maxFindings")
    def max_findings(self) -> pulumi.Input[int]:
        """
        Max findings limit for the given infoType.
        """
        return pulumi.get(self, "max_findings")

    @max_findings.setter
    def max_findings(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_findings", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetArgs:
    def __init__(__self__, *,
                 info_types: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs']]],
                 rules: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs']]] info_types: If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleArgs']]] rules: Set of rules to be applied to infoTypes. The rules are applied in order.
               Structure is documented below.
        """
        pulumi.set(__self__, "info_types", info_types)
        pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs']]]:
        """
        If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

    @info_types.setter
    def info_types(self, value: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs']]]):
        pulumi.set(self, "info_types", value)

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleArgs']]]:
        """
        Set of rules to be applied to infoTypes. The rules are applied in order.
        Structure is documented below.
        """
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleArgs']]]):
        pulumi.set(self, "rules", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleArgs:
    def __init__(__self__, *,
                 exclusion_rule: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs']] = None,
                 hotword_rule: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs']] = None):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs'] exclusion_rule: The rule that specifies conditions when findings of infoTypes specified in InspectionRuleSet are removed from results.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs'] hotword_rule: Hotword-based detection rule.
               Structure is documented below.
        """
        if exclusion_rule is not None:
            pulumi.set(__self__, "exclusion_rule", exclusion_rule)
        if hotword_rule is not None:
            pulumi.set(__self__, "hotword_rule", hotword_rule)

    @property
    @pulumi.getter(name="exclusionRule")
    def exclusion_rule(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs']]:
        """
        The rule that specifies conditions when findings of infoTypes specified in InspectionRuleSet are removed from results.
        Structure is documented below.
        """
        return pulumi.get(self, "exclusion_rule")

    @exclusion_rule.setter
    def exclusion_rule(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs']]):
        pulumi.set(self, "exclusion_rule", value)

    @property
    @pulumi.getter(name="hotwordRule")
    def hotword_rule(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs']]:
        """
        Hotword-based detection rule.
        Structure is documented below.
        """
        return pulumi.get(self, "hotword_rule")

    @hotword_rule.setter
    def hotword_rule(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs']]):
        pulumi.set(self, "hotword_rule", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs:
    def __init__(__self__, *,
                 matching_type: pulumi.Input[str],
                 dictionary: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs']] = None,
                 exclude_info_types: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs']] = None,
                 regex: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs']] = None):
        """
        :param pulumi.Input[str] matching_type: How the rule is applied. See the documentation for more information: https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#MatchingType
               Possible values are `MATCHING_TYPE_FULL_MATCH`, `MATCHING_TYPE_PARTIAL_MATCH`, and `MATCHING_TYPE_INVERSE_MATCH`.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs'] dictionary: Dictionary which defines the rule.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs'] exclude_info_types: Set of infoTypes for which findings would affect this rule.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs'] regex: Regular expression which defines the rule.
               Structure is documented below.
        """
        pulumi.set(__self__, "matching_type", matching_type)
        if dictionary is not None:
            pulumi.set(__self__, "dictionary", dictionary)
        if exclude_info_types is not None:
            pulumi.set(__self__, "exclude_info_types", exclude_info_types)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter(name="matchingType")
    def matching_type(self) -> pulumi.Input[str]:
        """
        How the rule is applied. See the documentation for more information: https://cloud.google.com/dlp/docs/reference/rest/v2/InspectConfig#MatchingType
        Possible values are `MATCHING_TYPE_FULL_MATCH`, `MATCHING_TYPE_PARTIAL_MATCH`, and `MATCHING_TYPE_INVERSE_MATCH`.
        """
        return pulumi.get(self, "matching_type")

    @matching_type.setter
    def matching_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "matching_type", value)

    @property
    @pulumi.getter
    def dictionary(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs']]:
        """
        Dictionary which defines the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "dictionary")

    @dictionary.setter
    def dictionary(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs']]):
        pulumi.set(self, "dictionary", value)

    @property
    @pulumi.getter(name="excludeInfoTypes")
    def exclude_info_types(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs']]:
        """
        Set of infoTypes for which findings would affect this rule.
        Structure is documented below.
        """
        return pulumi.get(self, "exclude_info_types")

    @exclude_info_types.setter
    def exclude_info_types(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs']]):
        pulumi.set(self, "exclude_info_types", value)

    @property
    @pulumi.getter
    def regex(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs']]:
        """
        Regular expression which defines the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "regex")

    @regex.setter
    def regex(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs']]):
        pulumi.set(self, "regex", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs:
    def __init__(__self__, *,
                 cloud_storage_path: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs']] = None,
                 word_list: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs']] = None):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs'] cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs'] word_list: List of words or phrases to search for.
               Structure is documented below.
        """
        if cloud_storage_path is not None:
            pulumi.set(__self__, "cloud_storage_path", cloud_storage_path)
        if word_list is not None:
            pulumi.set(__self__, "word_list", word_list)

    @property
    @pulumi.getter(name="cloudStoragePath")
    def cloud_storage_path(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs']]:
        """
        Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
        Structure is documented below.
        """
        return pulumi.get(self, "cloud_storage_path")

    @cloud_storage_path.setter
    def cloud_storage_path(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs']]):
        pulumi.set(self, "cloud_storage_path", value)

    @property
    @pulumi.getter(name="wordList")
    def word_list(self) -> Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs']]:
        """
        List of words or phrases to search for.
        Structure is documented below.
        """
        return pulumi.get(self, "word_list")

    @word_list.setter
    def word_list(self, value: Optional[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs']]):
        pulumi.set(self, "word_list", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        """
        :param pulumi.Input[str] path: A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordListArgs:
    def __init__(__self__, *,
                 words: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] 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.
        """
        pulumi.set(__self__, "words", words)

    @property
    @pulumi.getter
    def words(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        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.
        """
        return pulumi.get(self, "words")

    @words.setter
    def words(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "words", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs:
    def __init__(__self__, *,
                 info_types: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs']]] info_types: If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
               Structure is documented below.
        """
        pulumi.set(__self__, "info_types", info_types)

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs']]]:
        """
        If a finding is matched by any of the infoType detectors listed here, the finding will be excluded from the scan results.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

    @info_types.setter
    def info_types(self, value: pulumi.Input[Sequence[pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs']]]):
        pulumi.set(self, "info_types", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
               or `projects/project-id/storedInfoTypes/432452342`.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegexArgs:
    def __init__(__self__, *,
                 pattern: pulumi.Input[str],
                 group_indexes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input[str] pattern: Pattern defining the regular expression.
               Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] group_indexes: The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        pulumi.set(__self__, "pattern", pattern)
        if group_indexes is not None:
            pulumi.set(__self__, "group_indexes", group_indexes)

    @property
    @pulumi.getter
    def pattern(self) -> pulumi.Input[str]:
        """
        Pattern defining the regular expression.
        Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        """
        return pulumi.get(self, "pattern")

    @pattern.setter
    def pattern(self, value: pulumi.Input[str]):
        pulumi.set(self, "pattern", value)

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        return pulumi.get(self, "group_indexes")

    @group_indexes.setter
    def group_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "group_indexes", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs:
    def __init__(__self__, *,
                 hotword_regex: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs'],
                 likelihood_adjustment: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs'],
                 proximity: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs']):
        """
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs'] hotword_regex: Regular expression pattern defining what qualifies as a hotword.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs'] likelihood_adjustment: Likelihood adjustment to apply to all matching findings.
               Structure is documented below.
        :param pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs'] proximity: 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.
               Structure is documented below.
        """
        pulumi.set(__self__, "hotword_regex", hotword_regex)
        pulumi.set(__self__, "likelihood_adjustment", likelihood_adjustment)
        pulumi.set(__self__, "proximity", proximity)

    @property
    @pulumi.getter(name="hotwordRegex")
    def hotword_regex(self) -> pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs']:
        """
        Regular expression pattern defining what qualifies as a hotword.
        Structure is documented below.
        """
        return pulumi.get(self, "hotword_regex")

    @hotword_regex.setter
    def hotword_regex(self, value: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs']):
        pulumi.set(self, "hotword_regex", value)

    @property
    @pulumi.getter(name="likelihoodAdjustment")
    def likelihood_adjustment(self) -> pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs']:
        """
        Likelihood adjustment to apply to all matching findings.
        Structure is documented below.
        """
        return pulumi.get(self, "likelihood_adjustment")

    @likelihood_adjustment.setter
    def likelihood_adjustment(self, value: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs']):
        pulumi.set(self, "likelihood_adjustment", value)

    @property
    @pulumi.getter
    def proximity(self) -> pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs']:
        """
        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.
        Structure is documented below.
        """
        return pulumi.get(self, "proximity")

    @proximity.setter
    def proximity(self, value: pulumi.Input['PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs']):
        pulumi.set(self, "proximity", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs:
    def __init__(__self__, *,
                 pattern: pulumi.Input[str],
                 group_indexes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input[str] pattern: Pattern defining the regular expression.
               Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] group_indexes: The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        pulumi.set(__self__, "pattern", pattern)
        if group_indexes is not None:
            pulumi.set(__self__, "group_indexes", group_indexes)

    @property
    @pulumi.getter
    def pattern(self) -> pulumi.Input[str]:
        """
        Pattern defining the regular expression.
        Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        """
        return pulumi.get(self, "pattern")

    @pattern.setter
    def pattern(self, value: pulumi.Input[str]):
        pulumi.set(self, "pattern", value)

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        return pulumi.get(self, "group_indexes")

    @group_indexes.setter
    def group_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "group_indexes", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs:
    def __init__(__self__, *,
                 fixed_likelihood: Optional[pulumi.Input[str]] = None,
                 relative_likelihood: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] fixed_likelihood: Set the likelihood of a finding to a fixed value. Either this or relative_likelihood can be set.
               Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        :param pulumi.Input[int] relative_likelihood: Increase or decrease the likelihood by the specified number of levels. For example,
               if a finding would be POSSIBLE without the detection rule and relativeLikelihood 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. Either this or fixed_likelihood can be set.
        """
        if fixed_likelihood is not None:
            pulumi.set(__self__, "fixed_likelihood", fixed_likelihood)
        if relative_likelihood is not None:
            pulumi.set(__self__, "relative_likelihood", relative_likelihood)

    @property
    @pulumi.getter(name="fixedLikelihood")
    def fixed_likelihood(self) -> Optional[pulumi.Input[str]]:
        """
        Set the likelihood of a finding to a fixed value. Either this or relative_likelihood can be set.
        Possible values are `VERY_UNLIKELY`, `UNLIKELY`, `POSSIBLE`, `LIKELY`, and `VERY_LIKELY`.
        """
        return pulumi.get(self, "fixed_likelihood")

    @fixed_likelihood.setter
    def fixed_likelihood(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_likelihood", value)

    @property
    @pulumi.getter(name="relativeLikelihood")
    def relative_likelihood(self) -> Optional[pulumi.Input[int]]:
        """
        Increase or decrease the likelihood by the specified number of levels. For example,
        if a finding would be POSSIBLE without the detection rule and relativeLikelihood 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. Either this or fixed_likelihood can be set.
        """
        return pulumi.get(self, "relative_likelihood")

    @relative_likelihood.setter
    def relative_likelihood(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "relative_likelihood", value)


@pulumi.input_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs:
    def __init__(__self__, *,
                 window_after: Optional[pulumi.Input[int]] = None,
                 window_before: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] window_after: Number of characters after the finding to consider. Either this or window_before must be specified
        :param pulumi.Input[int] window_before: Number of characters before the finding to consider. Either this or window_after must be specified
        """
        if window_after is not None:
            pulumi.set(__self__, "window_after", window_after)
        if window_before is not None:
            pulumi.set(__self__, "window_before", window_before)

    @property
    @pulumi.getter(name="windowAfter")
    def window_after(self) -> Optional[pulumi.Input[int]]:
        """
        Number of characters after the finding to consider. Either this or window_before must be specified
        """
        return pulumi.get(self, "window_after")

    @window_after.setter
    def window_after(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "window_after", value)

    @property
    @pulumi.getter(name="windowBefore")
    def window_before(self) -> Optional[pulumi.Input[int]]:
        """
        Number of characters before the finding to consider. Either this or window_after must be specified
        """
        return pulumi.get(self, "window_before")

    @window_before.setter
    def window_before(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "window_before", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input['PreventionJobTriggerInspectJobActionArgs']]],
                 inspect_template_name: pulumi.Input[str],
                 storage_config: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigArgs']):
        """
        :param pulumi.Input[Sequence[pulumi.Input['PreventionJobTriggerInspectJobActionArgs']]] actions: A task to execute on the completion of a job.
               Structure is documented below.
        :param pulumi.Input[str] inspect_template_name: The name of the template to run when this job is triggered.
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigArgs'] storage_config: Information on where to inspect
               Structure is documented below.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "inspect_template_name", inspect_template_name)
        pulumi.set(__self__, "storage_config", storage_config)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[Sequence[pulumi.Input['PreventionJobTriggerInspectJobActionArgs']]]:
        """
        A task to execute on the completion of a job.
        Structure is documented below.
        """
        return pulumi.get(self, "actions")

    @actions.setter
    def actions(self, value: pulumi.Input[Sequence[pulumi.Input['PreventionJobTriggerInspectJobActionArgs']]]):
        pulumi.set(self, "actions", value)

    @property
    @pulumi.getter(name="inspectTemplateName")
    def inspect_template_name(self) -> pulumi.Input[str]:
        """
        The name of the template to run when this job is triggered.
        """
        return pulumi.get(self, "inspect_template_name")

    @inspect_template_name.setter
    def inspect_template_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "inspect_template_name", value)

    @property
    @pulumi.getter(name="storageConfig")
    def storage_config(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigArgs']:
        """
        Information on where to inspect
        Structure is documented below.
        """
        return pulumi.get(self, "storage_config")

    @storage_config.setter
    def storage_config(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigArgs']):
        pulumi.set(self, "storage_config", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobActionArgs:
    def __init__(__self__, *,
                 save_findings: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsArgs']):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsArgs'] save_findings: Schedule for triggered jobs
               Structure is documented below.
        """
        pulumi.set(__self__, "save_findings", save_findings)

    @property
    @pulumi.getter(name="saveFindings")
    def save_findings(self) -> pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsArgs']:
        """
        Schedule for triggered jobs
        Structure is documented below.
        """
        return pulumi.get(self, "save_findings")

    @save_findings.setter
    def save_findings(self, value: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsArgs']):
        pulumi.set(self, "save_findings", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobActionSaveFindingsArgs:
    def __init__(__self__, *,
                 output_config: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs']):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs'] output_config: Information on where to store output
               Structure is documented below.
        """
        pulumi.set(__self__, "output_config", output_config)

    @property
    @pulumi.getter(name="outputConfig")
    def output_config(self) -> pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs']:
        """
        Information on where to store output
        Structure is documented below.
        """
        return pulumi.get(self, "output_config")

    @output_config.setter
    def output_config(self, value: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs']):
        pulumi.set(self, "output_config", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigArgs:
    def __init__(__self__, *,
                 table: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs'],
                 output_schema: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs'] table: Information on the location of the target BigQuery Table.
               Structure is documented below.
        :param pulumi.Input[str] output_schema: Schema used for writing the findings for Inspect jobs. This field is only used for
               Inspect and must be unspecified for Risk jobs. Columns are derived from the Finding
               object. If appending to an existing table, any columns from the predefined schema
               that are missing will be added. No columns in the existing table will be deleted.
               If unspecified, then all available columns will be used for a new table or an (existing)
               table with no schema, and no changes will be made to an existing table that has a schema.
               Only for use with external storage.
               Possible values are `BASIC_COLUMNS`, `GCS_COLUMNS`, `DATASTORE_COLUMNS`, `BIG_QUERY_COLUMNS`, and `ALL_COLUMNS`.
        """
        pulumi.set(__self__, "table", table)
        if output_schema is not None:
            pulumi.set(__self__, "output_schema", output_schema)

    @property
    @pulumi.getter
    def table(self) -> pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs']:
        """
        Information on the location of the target BigQuery Table.
        Structure is documented below.
        """
        return pulumi.get(self, "table")

    @table.setter
    def table(self, value: pulumi.Input['PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs']):
        pulumi.set(self, "table", value)

    @property
    @pulumi.getter(name="outputSchema")
    def output_schema(self) -> Optional[pulumi.Input[str]]:
        """
        Schema used for writing the findings for Inspect jobs. This field is only used for
        Inspect and must be unspecified for Risk jobs. Columns are derived from the Finding
        object. If appending to an existing table, any columns from the predefined schema
        that are missing will be added. No columns in the existing table will be deleted.
        If unspecified, then all available columns will be used for a new table or an (existing)
        table with no schema, and no changes will be made to an existing table that has a schema.
        Only for use with external storage.
        Possible values are `BASIC_COLUMNS`, `GCS_COLUMNS`, `DATASTORE_COLUMNS`, `BIG_QUERY_COLUMNS`, and `ALL_COLUMNS`.
        """
        return pulumi.get(self, "output_schema")

    @output_schema.setter
    def output_schema(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_schema", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs:
    def __init__(__self__, *,
                 dataset_id: pulumi.Input[str],
                 project_id: pulumi.Input[str],
                 table_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] dataset_id: Dataset ID of the table.
        :param pulumi.Input[str] project_id: The Google Cloud Platform project ID of the project containing the table.
        :param pulumi.Input[str] table_id: Name of the table. If is not set a new one will be generated for you with the following format:
               `dlp_googleapis_yyyy_mm_dd_[dlp_job_id]`. Pacific timezone will be used for generating the date details.
        """
        pulumi.set(__self__, "dataset_id", dataset_id)
        pulumi.set(__self__, "project_id", project_id)
        if table_id is not None:
            pulumi.set(__self__, "table_id", table_id)

    @property
    @pulumi.getter(name="datasetId")
    def dataset_id(self) -> pulumi.Input[str]:
        """
        Dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

    @dataset_id.setter
    def dataset_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "dataset_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The Google Cloud Platform project ID of the project containing the table.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="tableId")
    def table_id(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the table. If is not set a new one will be generated for you with the following format:
        `dlp_googleapis_yyyy_mm_dd_[dlp_job_id]`. Pacific timezone will be used for generating the date details.
        """
        return pulumi.get(self, "table_id")

    @table_id.setter
    def table_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "table_id", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigArgs:
    def __init__(__self__, *,
                 big_query_options: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs']] = None,
                 cloud_storage_options: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs']] = None,
                 datastore_options: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs']] = None,
                 timespan_config: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs']] = None):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs'] big_query_options: Options defining BigQuery table and row identifiers.
               Structure is documented below.
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs'] cloud_storage_options: Options defining a file or a set of files within a Google Cloud Storage bucket.
               Structure is documented below.
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs'] datastore_options: Options defining a data set within Google Cloud Datastore.
               Structure is documented below.
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs'] timespan_config: Information on where to inspect
               Structure is documented below.
        """
        if big_query_options is not None:
            pulumi.set(__self__, "big_query_options", big_query_options)
        if cloud_storage_options is not None:
            pulumi.set(__self__, "cloud_storage_options", cloud_storage_options)
        if datastore_options is not None:
            pulumi.set(__self__, "datastore_options", datastore_options)
        if timespan_config is not None:
            pulumi.set(__self__, "timespan_config", timespan_config)

    @property
    @pulumi.getter(name="bigQueryOptions")
    def big_query_options(self) -> Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs']]:
        """
        Options defining BigQuery table and row identifiers.
        Structure is documented below.
        """
        return pulumi.get(self, "big_query_options")

    @big_query_options.setter
    def big_query_options(self, value: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs']]):
        pulumi.set(self, "big_query_options", value)

    @property
    @pulumi.getter(name="cloudStorageOptions")
    def cloud_storage_options(self) -> Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs']]:
        """
        Options defining a file or a set of files within a Google Cloud Storage bucket.
        Structure is documented below.
        """
        return pulumi.get(self, "cloud_storage_options")

    @cloud_storage_options.setter
    def cloud_storage_options(self, value: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs']]):
        pulumi.set(self, "cloud_storage_options", value)

    @property
    @pulumi.getter(name="datastoreOptions")
    def datastore_options(self) -> Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs']]:
        """
        Options defining a data set within Google Cloud Datastore.
        Structure is documented below.
        """
        return pulumi.get(self, "datastore_options")

    @datastore_options.setter
    def datastore_options(self, value: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs']]):
        pulumi.set(self, "datastore_options", value)

    @property
    @pulumi.getter(name="timespanConfig")
    def timespan_config(self) -> Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs']]:
        """
        Information on where to inspect
        Structure is documented below.
        """
        return pulumi.get(self, "timespan_config")

    @timespan_config.setter
    def timespan_config(self, value: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs']]):
        pulumi.set(self, "timespan_config", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs:
    def __init__(__self__, *,
                 table_reference: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs']):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs'] table_reference: Set of files to scan.
               Structure is documented below.
        """
        pulumi.set(__self__, "table_reference", table_reference)

    @property
    @pulumi.getter(name="tableReference")
    def table_reference(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs']:
        """
        Set of files to scan.
        Structure is documented below.
        """
        return pulumi.get(self, "table_reference")

    @table_reference.setter
    def table_reference(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs']):
        pulumi.set(self, "table_reference", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs:
    def __init__(__self__, *,
                 dataset_id: pulumi.Input[str],
                 project_id: pulumi.Input[str],
                 table_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] dataset_id: Dataset ID of the table.
        :param pulumi.Input[str] project_id: The Google Cloud Platform project ID of the project containing the table.
        :param pulumi.Input[str] table_id: Name of the table. If is not set a new one will be generated for you with the following format:
               `dlp_googleapis_yyyy_mm_dd_[dlp_job_id]`. Pacific timezone will be used for generating the date details.
        """
        pulumi.set(__self__, "dataset_id", dataset_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "table_id", table_id)

    @property
    @pulumi.getter(name="datasetId")
    def dataset_id(self) -> pulumi.Input[str]:
        """
        Dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

    @dataset_id.setter
    def dataset_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "dataset_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The Google Cloud Platform project ID of the project containing the table.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="tableId")
    def table_id(self) -> pulumi.Input[str]:
        """
        Name of the table. If is not set a new one will be generated for you with the following format:
        `dlp_googleapis_yyyy_mm_dd_[dlp_job_id]`. Pacific timezone will be used for generating the date details.
        """
        return pulumi.get(self, "table_id")

    @table_id.setter
    def table_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_id", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs:
    def __init__(__self__, *,
                 file_set: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs'],
                 bytes_limit_per_file: Optional[pulumi.Input[int]] = None,
                 bytes_limit_per_file_percent: Optional[pulumi.Input[int]] = None,
                 file_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 files_limit_percent: Optional[pulumi.Input[int]] = None,
                 sample_method: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs'] file_set: Set of files to scan.
               Structure is documented below.
        :param pulumi.Input[int] bytes_limit_per_file: Max number of bytes to scan from a file. If a scanned file's size is bigger than this value
               then the rest of the bytes are omitted.
        :param pulumi.Input[int] bytes_limit_per_file_percent: Max percentage of bytes to scan from a file. The rest are omitted. The number of bytes scanned is rounded down.
               Must be between 0 and 100, inclusively. Both 0 and 100 means no limit.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] file_types: List of file type groups to include in the scan. If empty, all files are scanned and available data
               format processors are applied. In addition, the binary content of the selected files is always scanned as well.
               Images are scanned only as binary if the specified region does not support image inspection and no fileTypes were specified.
               Each value may be one of `BINARY_FILE`, `TEXT_FILE`, `IMAGE`, `WORD`, `PDF`, `AVRO`, `CSV`, and `TSV`.
        :param pulumi.Input[int] files_limit_percent: Limits the number of files to scan to this percentage of the input FileSet. Number of files scanned is rounded down.
               Must be between 0 and 100, inclusively. Both 0 and 100 means no limit.
        :param pulumi.Input[str] sample_method: How to sample bytes if not all bytes are scanned. Meaningful only when used in conjunction with bytesLimitPerFile.
               If not specified, scanning would start from the top.
               Possible values are `TOP` and `RANDOM_START`.
        """
        pulumi.set(__self__, "file_set", file_set)
        if bytes_limit_per_file is not None:
            pulumi.set(__self__, "bytes_limit_per_file", bytes_limit_per_file)
        if bytes_limit_per_file_percent is not None:
            pulumi.set(__self__, "bytes_limit_per_file_percent", bytes_limit_per_file_percent)
        if file_types is not None:
            pulumi.set(__self__, "file_types", file_types)
        if files_limit_percent is not None:
            pulumi.set(__self__, "files_limit_percent", files_limit_percent)
        if sample_method is not None:
            pulumi.set(__self__, "sample_method", sample_method)

    @property
    @pulumi.getter(name="fileSet")
    def file_set(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs']:
        """
        Set of files to scan.
        Structure is documented below.
        """
        return pulumi.get(self, "file_set")

    @file_set.setter
    def file_set(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs']):
        pulumi.set(self, "file_set", value)

    @property
    @pulumi.getter(name="bytesLimitPerFile")
    def bytes_limit_per_file(self) -> Optional[pulumi.Input[int]]:
        """
        Max number of bytes to scan from a file. If a scanned file's size is bigger than this value
        then the rest of the bytes are omitted.
        """
        return pulumi.get(self, "bytes_limit_per_file")

    @bytes_limit_per_file.setter
    def bytes_limit_per_file(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bytes_limit_per_file", value)

    @property
    @pulumi.getter(name="bytesLimitPerFilePercent")
    def bytes_limit_per_file_percent(self) -> Optional[pulumi.Input[int]]:
        """
        Max percentage of bytes to scan from a file. The rest are omitted. The number of bytes scanned is rounded down.
        Must be between 0 and 100, inclusively. Both 0 and 100 means no limit.
        """
        return pulumi.get(self, "bytes_limit_per_file_percent")

    @bytes_limit_per_file_percent.setter
    def bytes_limit_per_file_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bytes_limit_per_file_percent", value)

    @property
    @pulumi.getter(name="fileTypes")
    def file_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of file type groups to include in the scan. If empty, all files are scanned and available data
        format processors are applied. In addition, the binary content of the selected files is always scanned as well.
        Images are scanned only as binary if the specified region does not support image inspection and no fileTypes were specified.
        Each value may be one of `BINARY_FILE`, `TEXT_FILE`, `IMAGE`, `WORD`, `PDF`, `AVRO`, `CSV`, and `TSV`.
        """
        return pulumi.get(self, "file_types")

    @file_types.setter
    def file_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "file_types", value)

    @property
    @pulumi.getter(name="filesLimitPercent")
    def files_limit_percent(self) -> Optional[pulumi.Input[int]]:
        """
        Limits the number of files to scan to this percentage of the input FileSet. Number of files scanned is rounded down.
        Must be between 0 and 100, inclusively. Both 0 and 100 means no limit.
        """
        return pulumi.get(self, "files_limit_percent")

    @files_limit_percent.setter
    def files_limit_percent(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "files_limit_percent", value)

    @property
    @pulumi.getter(name="sampleMethod")
    def sample_method(self) -> Optional[pulumi.Input[str]]:
        """
        How to sample bytes if not all bytes are scanned. Meaningful only when used in conjunction with bytesLimitPerFile.
        If not specified, scanning would start from the top.
        Possible values are `TOP` and `RANDOM_START`.
        """
        return pulumi.get(self, "sample_method")

    @sample_method.setter
    def sample_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sample_method", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs:
    def __init__(__self__, *,
                 regex_file_set: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs']] = None,
                 url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs'] regex_file_set: The regex-filtered set of files to scan.
               Structure is documented below.
        :param pulumi.Input[str] url: The Cloud Storage url of the file(s) to scan, in the format `gs://<bucket>/<path>`. Trailing wildcard
               in the path is allowed.
               If the url ends in a trailing slash, the bucket or directory represented by the url will be scanned
               non-recursively (content in sub-directories will not be scanned). This means that `gs://mybucket/` is
               equivalent to `gs://mybucket/*`, and `gs://mybucket/directory/` is equivalent to `gs://mybucket/directory/*`.
        """
        if regex_file_set is not None:
            pulumi.set(__self__, "regex_file_set", regex_file_set)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter(name="regexFileSet")
    def regex_file_set(self) -> Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs']]:
        """
        The regex-filtered set of files to scan.
        Structure is documented below.
        """
        return pulumi.get(self, "regex_file_set")

    @regex_file_set.setter
    def regex_file_set(self, value: Optional[pulumi.Input['PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs']]):
        pulumi.set(self, "regex_file_set", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        """
        The Cloud Storage url of the file(s) to scan, in the format `gs://<bucket>/<path>`. Trailing wildcard
        in the path is allowed.
        If the url ends in a trailing slash, the bucket or directory represented by the url will be scanned
        non-recursively (content in sub-directories will not be scanned). This means that `gs://mybucket/` is
        equivalent to `gs://mybucket/*`, and `gs://mybucket/directory/` is equivalent to `gs://mybucket/directory/*`.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 exclude_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] bucket_name: The name of a Cloud Storage bucket.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_regexes: A list of regular expressions matching file paths to exclude. All files in the bucket that match at
               least one of these regular expressions will be excluded from the scan.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_regexes: A list of regular expressions matching file paths to include. All files in the bucket
               that match at least one of these regular expressions will be included in the set of files,
               except for those that also match an item in excludeRegex. Leaving this field empty will
               match all files by default (this is equivalent to including .* in the list)
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        if exclude_regexes is not None:
            pulumi.set(__self__, "exclude_regexes", exclude_regexes)
        if include_regexes is not None:
            pulumi.set(__self__, "include_regexes", include_regexes)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        """
        The name of a Cloud Storage bucket.
        """
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

    @property
    @pulumi.getter(name="excludeRegexes")
    def exclude_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of regular expressions matching file paths to exclude. All files in the bucket that match at
        least one of these regular expressions will be excluded from the scan.
        """
        return pulumi.get(self, "exclude_regexes")

    @exclude_regexes.setter
    def exclude_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_regexes", value)

    @property
    @pulumi.getter(name="includeRegexes")
    def include_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of regular expressions matching file paths to include. All files in the bucket
        that match at least one of these regular expressions will be included in the set of files,
        except for those that also match an item in excludeRegex. Leaving this field empty will
        match all files by default (this is equivalent to including .* in the list)
        """
        return pulumi.get(self, "include_regexes")

    @include_regexes.setter
    def include_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_regexes", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs:
    def __init__(__self__, *,
                 kind: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs'],
                 partition_id: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs']):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs'] kind: A representation of a Datastore kind.
               Structure is documented below.
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs'] partition_id: Datastore partition ID. A partition ID identifies a grouping of entities. The grouping
               is always by project and namespace, however the namespace ID may be empty.
               Structure is documented below.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "partition_id", partition_id)

    @property
    @pulumi.getter
    def kind(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs']:
        """
        A representation of a Datastore kind.
        Structure is documented below.
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs']):
        pulumi.set(self, "kind", value)

    @property
    @pulumi.getter(name="partitionId")
    def partition_id(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs']:
        """
        Datastore partition ID. A partition ID identifies a grouping of entities. The grouping
        is always by project and namespace, however the namespace ID may be empty.
        Structure is documented below.
        """
        return pulumi.get(self, "partition_id")

    @partition_id.setter
    def partition_id(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs']):
        pulumi.set(self, "partition_id", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the Datastore kind.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the Datastore kind.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionIdArgs:
    def __init__(__self__, *,
                 project_id: pulumi.Input[str],
                 namespace_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] project_id: The Google Cloud Platform project ID of the project containing the table.
        :param pulumi.Input[str] namespace_id: If not empty, the ID of the namespace to which the entities belong.
        """
        pulumi.set(__self__, "project_id", project_id)
        if namespace_id is not None:
            pulumi.set(__self__, "namespace_id", namespace_id)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The Google Cloud Platform project ID of the project containing the table.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="namespaceId")
    def namespace_id(self) -> Optional[pulumi.Input[str]]:
        """
        If not empty, the ID of the namespace to which the entities belong.
        """
        return pulumi.get(self, "namespace_id")

    @namespace_id.setter
    def namespace_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "namespace_id", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigTimespanConfigArgs:
    def __init__(__self__, *,
                 timestamp_field: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs'],
                 enable_auto_population_of_timespan_config: Optional[pulumi.Input[bool]] = None,
                 end_time: Optional[pulumi.Input[str]] = None,
                 start_time: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs'] timestamp_field: Information on where to inspect
               Structure is documented below.
        :param pulumi.Input[bool] enable_auto_population_of_timespan_config: When the job is started by a JobTrigger we will automatically figure out a valid startTime to avoid
               scanning files that have not been modified since the last time the JobTrigger executed. This will
               be based on the time of the execution of the last run of the JobTrigger.
        :param pulumi.Input[str] end_time: Exclude files or rows newer than this value. If set to zero, no upper time limit is applied.
        :param pulumi.Input[str] start_time: Exclude files or rows older than this value.
        """
        pulumi.set(__self__, "timestamp_field", timestamp_field)
        if enable_auto_population_of_timespan_config is not None:
            pulumi.set(__self__, "enable_auto_population_of_timespan_config", enable_auto_population_of_timespan_config)
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="timestampField")
    def timestamp_field(self) -> pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs']:
        """
        Information on where to inspect
        Structure is documented below.
        """
        return pulumi.get(self, "timestamp_field")

    @timestamp_field.setter
    def timestamp_field(self, value: pulumi.Input['PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs']):
        pulumi.set(self, "timestamp_field", value)

    @property
    @pulumi.getter(name="enableAutoPopulationOfTimespanConfig")
    def enable_auto_population_of_timespan_config(self) -> Optional[pulumi.Input[bool]]:
        """
        When the job is started by a JobTrigger we will automatically figure out a valid startTime to avoid
        scanning files that have not been modified since the last time the JobTrigger executed. This will
        be based on the time of the execution of the last run of the JobTrigger.
        """
        return pulumi.get(self, "enable_auto_population_of_timespan_config")

    @enable_auto_population_of_timespan_config.setter
    def enable_auto_population_of_timespan_config(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_auto_population_of_timespan_config", value)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[pulumi.Input[str]]:
        """
        Exclude files or rows newer than this value. If set to zero, no upper time limit is applied.
        """
        return pulumi.get(self, "end_time")

    @end_time.setter
    def end_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "end_time", value)

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[str]]:
        """
        Exclude files or rows older than this value.
        """
        return pulumi.get(self, "start_time")

    @start_time.setter
    def start_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: The name of the Datastore kind.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the Datastore kind.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionJobTriggerTriggerArgs:
    def __init__(__self__, *,
                 schedule: Optional[pulumi.Input['PreventionJobTriggerTriggerScheduleArgs']] = None):
        """
        :param pulumi.Input['PreventionJobTriggerTriggerScheduleArgs'] schedule: Schedule for triggered jobs
               Structure is documented below.
        """
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def schedule(self) -> Optional[pulumi.Input['PreventionJobTriggerTriggerScheduleArgs']]:
        """
        Schedule for triggered jobs
        Structure is documented below.
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: Optional[pulumi.Input['PreventionJobTriggerTriggerScheduleArgs']]):
        pulumi.set(self, "schedule", value)


@pulumi.input_type
class PreventionJobTriggerTriggerScheduleArgs:
    def __init__(__self__, *,
                 recurrence_period_duration: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] recurrence_period_duration: With this option a job is started a regular periodic basis. For example: every day (86400 seconds).
               A scheduled start time will be skipped if the previous execution has not ended when its scheduled time occurs.
               This value must be set to a time duration greater than or equal to 1 day and can be no longer than 60 days.
               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        if recurrence_period_duration is not None:
            pulumi.set(__self__, "recurrence_period_duration", recurrence_period_duration)

    @property
    @pulumi.getter(name="recurrencePeriodDuration")
    def recurrence_period_duration(self) -> Optional[pulumi.Input[str]]:
        """
        With this option a job is started a regular periodic basis. For example: every day (86400 seconds).
        A scheduled start time will be skipped if the previous execution has not ended when its scheduled time occurs.
        This value must be set to a time duration greater than or equal to 1 day and can be no longer than 60 days.
        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        return pulumi.get(self, "recurrence_period_duration")

    @recurrence_period_duration.setter
    def recurrence_period_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recurrence_period_duration", value)


@pulumi.input_type
class PreventionStoredInfoTypeDictionaryArgs:
    def __init__(__self__, *,
                 cloud_storage_path: Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryCloudStoragePathArgs']] = None,
                 word_list: Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryWordListArgs']] = None):
        """
        :param pulumi.Input['PreventionStoredInfoTypeDictionaryCloudStoragePathArgs'] cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param pulumi.Input['PreventionStoredInfoTypeDictionaryWordListArgs'] word_list: List of words or phrases to search for.
               Structure is documented below.
        """
        if cloud_storage_path is not None:
            pulumi.set(__self__, "cloud_storage_path", cloud_storage_path)
        if word_list is not None:
            pulumi.set(__self__, "word_list", word_list)

    @property
    @pulumi.getter(name="cloudStoragePath")
    def cloud_storage_path(self) -> Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryCloudStoragePathArgs']]:
        """
        Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
        Structure is documented below.
        """
        return pulumi.get(self, "cloud_storage_path")

    @cloud_storage_path.setter
    def cloud_storage_path(self, value: Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryCloudStoragePathArgs']]):
        pulumi.set(self, "cloud_storage_path", value)

    @property
    @pulumi.getter(name="wordList")
    def word_list(self) -> Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryWordListArgs']]:
        """
        List of words or phrases to search for.
        Structure is documented below.
        """
        return pulumi.get(self, "word_list")

    @word_list.setter
    def word_list(self, value: Optional[pulumi.Input['PreventionStoredInfoTypeDictionaryWordListArgs']]):
        pulumi.set(self, "word_list", value)


@pulumi.input_type
class PreventionStoredInfoTypeDictionaryCloudStoragePathArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        """
        :param pulumi.Input[str] path: A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)


@pulumi.input_type
class PreventionStoredInfoTypeDictionaryWordListArgs:
    def __init__(__self__, *,
                 words: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] 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.
        """
        pulumi.set(__self__, "words", words)

    @property
    @pulumi.getter
    def words(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        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.
        """
        return pulumi.get(self, "words")

    @words.setter
    def words(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "words", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryArgs:
    def __init__(__self__, *,
                 output_path: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs'],
                 big_query_field: Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs']] = None,
                 cloud_storage_file_set: Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs']] = None):
        """
        :param pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs'] output_path: Location to store dictionary artifacts in Google Cloud Storage. These files will only be accessible by project owners and the DLP API.
               If any of these artifacts are modified, the dictionary is considered invalid and can no longer be used.
               Structure is documented below.
        :param pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs'] big_query_field: Field in a BigQuery table where each cell represents a dictionary phrase.
               Structure is documented below.
        :param pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs'] cloud_storage_file_set: Set of files containing newline-delimited lists of dictionary phrases.
               Structure is documented below.
        """
        pulumi.set(__self__, "output_path", output_path)
        if big_query_field is not None:
            pulumi.set(__self__, "big_query_field", big_query_field)
        if cloud_storage_file_set is not None:
            pulumi.set(__self__, "cloud_storage_file_set", cloud_storage_file_set)

    @property
    @pulumi.getter(name="outputPath")
    def output_path(self) -> pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs']:
        """
        Location to store dictionary artifacts in Google Cloud Storage. These files will only be accessible by project owners and the DLP API.
        If any of these artifacts are modified, the dictionary is considered invalid and can no longer be used.
        Structure is documented below.
        """
        return pulumi.get(self, "output_path")

    @output_path.setter
    def output_path(self, value: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs']):
        pulumi.set(self, "output_path", value)

    @property
    @pulumi.getter(name="bigQueryField")
    def big_query_field(self) -> Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs']]:
        """
        Field in a BigQuery table where each cell represents a dictionary phrase.
        Structure is documented below.
        """
        return pulumi.get(self, "big_query_field")

    @big_query_field.setter
    def big_query_field(self, value: Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs']]):
        pulumi.set(self, "big_query_field", value)

    @property
    @pulumi.getter(name="cloudStorageFileSet")
    def cloud_storage_file_set(self) -> Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs']]:
        """
        Set of files containing newline-delimited lists of dictionary phrases.
        Structure is documented below.
        """
        return pulumi.get(self, "cloud_storage_file_set")

    @cloud_storage_file_set.setter
    def cloud_storage_file_set(self, value: Optional[pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs']]):
        pulumi.set(self, "cloud_storage_file_set", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs:
    def __init__(__self__, *,
                 field: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs'],
                 table: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs']):
        """
        :param pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs'] field: Designated field in the BigQuery table.
               Structure is documented below.
        :param pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs'] table: Field in a BigQuery table where each cell represents a dictionary phrase.
               Structure is documented below.
        """
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "table", table)

    @property
    @pulumi.getter
    def field(self) -> pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs']:
        """
        Designated field in the BigQuery table.
        Structure is documented below.
        """
        return pulumi.get(self, "field")

    @field.setter
    def field(self, value: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs']):
        pulumi.set(self, "field", value)

    @property
    @pulumi.getter
    def table(self) -> pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs']:
        """
        Field in a BigQuery table where each cell represents a dictionary phrase.
        Structure is documented below.
        """
        return pulumi.get(self, "table")

    @table.setter
    def table(self, value: pulumi.Input['PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs']):
        pulumi.set(self, "table", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Name describing the field.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Name describing the field.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTableArgs:
    def __init__(__self__, *,
                 dataset_id: pulumi.Input[str],
                 project_id: pulumi.Input[str],
                 table_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] dataset_id: The dataset ID of the table.
        :param pulumi.Input[str] project_id: The Google Cloud Platform project ID of the project containing the table.
        :param pulumi.Input[str] table_id: The name of the table.
        """
        pulumi.set(__self__, "dataset_id", dataset_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "table_id", table_id)

    @property
    @pulumi.getter(name="datasetId")
    def dataset_id(self) -> pulumi.Input[str]:
        """
        The dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

    @dataset_id.setter
    def dataset_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "dataset_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        The Google Cloud Platform project ID of the project containing the table.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="tableId")
    def table_id(self) -> pulumi.Input[str]:
        """
        The name of the table.
        """
        return pulumi.get(self, "table_id")

    @table_id.setter
    def table_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_id", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSetArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str]):
        """
        :param pulumi.Input[str] url: The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the path is allowed.
        """
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the path is allowed.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)


@pulumi.input_type
class PreventionStoredInfoTypeLargeCustomDictionaryOutputPathArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        """
        :param pulumi.Input[str] path: A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: pulumi.Input[str]):
        pulumi.set(self, "path", value)


@pulumi.input_type
class PreventionStoredInfoTypeRegexArgs:
    def __init__(__self__, *,
                 pattern: pulumi.Input[str],
                 group_indexes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input[str] pattern: Pattern defining the regular expression.
               Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] group_indexes: The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        pulumi.set(__self__, "pattern", pattern)
        if group_indexes is not None:
            pulumi.set(__self__, "group_indexes", group_indexes)

    @property
    @pulumi.getter
    def pattern(self) -> pulumi.Input[str]:
        """
        Pattern defining the regular expression.
        Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the google/re2 repository on GitHub.
        """
        return pulumi.get(self, "pattern")

    @pattern.setter
    def pattern(self, value: pulumi.Input[str]):
        pulumi.set(self, "pattern", value)

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        The index of the submatch to extract as findings. When not specified, the entire match is returned. No more than 3 may be included.
        """
        return pulumi.get(self, "group_indexes")

    @group_indexes.setter
    def group_indexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "group_indexes", value)


