# 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
from . import outputs

__all__ = [
    'PreventionDeidentifyTemplateDeidentifyConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformations',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoType',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContext',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationCondition',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditions',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsCondition',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionField',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationField',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigContext',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigContext',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyTransient',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyUnwrapped',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationRedactConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigWordList',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppression',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionCondition',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditions',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsCondition',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionField',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueDateValue',
    'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueTimeValue',
    'PreventionInspectTemplateInspectConfig',
    'PreventionInspectTemplateInspectConfigCustomInfoType',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePath',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordList',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeInfoType',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeRegex',
    'PreventionInspectTemplateInspectConfigCustomInfoTypeStoredType',
    'PreventionInspectTemplateInspectConfigInfoType',
    'PreventionInspectTemplateInspectConfigLimits',
    'PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType',
    'PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoType',
    'PreventionInspectTemplateInspectConfigRuleSet',
    'PreventionInspectTemplateInspectConfigRuleSetInfoType',
    'PreventionInspectTemplateInspectConfigRuleSetRule',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePath',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordList',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoType',
    'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment',
    'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity',
    'PreventionJobTriggerInspectJob',
    'PreventionJobTriggerInspectJobAction',
    'PreventionJobTriggerInspectJobActionPubSub',
    'PreventionJobTriggerInspectJobActionPublishFindingsToCloudDataCatalog',
    'PreventionJobTriggerInspectJobActionPublishSummaryToCscc',
    'PreventionJobTriggerInspectJobActionSaveFindings',
    'PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig',
    'PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable',
    'PreventionJobTriggerInspectJobStorageConfig',
    'PreventionJobTriggerInspectJobStorageConfigBigQueryOptions',
    'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsIdentifyingField',
    'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet',
    'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptions',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKind',
    'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId',
    'PreventionJobTriggerInspectJobStorageConfigTimespanConfig',
    'PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampField',
    'PreventionJobTriggerTrigger',
    'PreventionJobTriggerTriggerSchedule',
    'PreventionStoredInfoTypeDictionary',
    'PreventionStoredInfoTypeDictionaryCloudStoragePath',
    'PreventionStoredInfoTypeDictionaryWordList',
    'PreventionStoredInfoTypeLargeCustomDictionary',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryField',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldField',
    'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable',
    'PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSet',
    'PreventionStoredInfoTypeLargeCustomDictionaryOutputPath',
    'PreventionStoredInfoTypeRegex',
]

@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "infoTypeTransformations":
            suggest = "info_type_transformations"
        elif key == "recordTransformations":
            suggest = "record_transformations"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 info_type_transformations: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformations'] = None,
                 record_transformations: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsArgs' info_type_transformations: Treat the dataset as free-form text and apply the same free text transformation everywhere
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsArgs' record_transformations: Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.
               Structure is documented below.
        """
        if info_type_transformations is not None:
            pulumi.set(__self__, "info_type_transformations", info_type_transformations)
        if record_transformations is not None:
            pulumi.set(__self__, "record_transformations", record_transformations)

    @property
    @pulumi.getter(name="infoTypeTransformations")
    def info_type_transformations(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformations']:
        """
        Treat the dataset as free-form text and apply the same free text transformation everywhere
        Structure is documented below.
        """
        return pulumi.get(self, "info_type_transformations")

    @property
    @pulumi.getter(name="recordTransformations")
    def record_transformations(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations']:
        """
        Treat the dataset as structured. Transformations can be applied to specific locations within structured datasets, such as transforming a column within a table.
        Structure is documented below.
        """
        return pulumi.get(self, "record_transformations")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformations(dict):
    def __init__(__self__, *,
                 transformations: Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation']):
        """
        :param Sequence['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) -> Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation']:
        """
        Transformation for each infoType. Cannot specify more than one for a given infoType.
        Structure is documented below.
        """
        return pulumi.get(self, "transformations")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "primitiveTransformation":
            suggest = "primitive_transformation"
        elif key == "infoTypes":
            suggest = "info_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 primitive_transformation: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation',
                 info_types: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoType']] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationArgs' primitive_transformation: Primitive transformation to apply to the infoType.
               The `primitive_transformation` block must only contain one argument, corresponding to the type of transformation.
               Structure is documented below.
        :param Sequence['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) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation':
        """
        Primitive transformation to apply to the infoType.
        The `primitive_transformation` block must only contain one argument, corresponding to the type of transformation.
        Structure is documented below.
        """
        return pulumi.get(self, "primitive_transformation")

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoType']]:
        """
        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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationInfoType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the information type.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the information type.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "characterMaskConfig":
            suggest = "character_mask_config"
        elif key == "cryptoDeterministicConfig":
            suggest = "crypto_deterministic_config"
        elif key == "cryptoReplaceFfxFpeConfig":
            suggest = "crypto_replace_ffx_fpe_config"
        elif key == "replaceConfig":
            suggest = "replace_config"
        elif key == "replaceWithInfoTypeConfig":
            suggest = "replace_with_info_type_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 character_mask_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig'] = None,
                 crypto_deterministic_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig'] = None,
                 crypto_replace_ffx_fpe_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig'] = None,
                 replace_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig'] = None,
                 replace_with_info_type_config: Optional[bool] = None):
        """
        :param '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. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3).
               Structure is documented below.
        :param '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 '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 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigArgs' replace_config: Replace with a specified value.
               Structure is documented below.
        :param 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['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig']:
        """
        Partially mask a string by replacing a given number of characters with a fixed character. Masking can start from the beginning or end of the string. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3).
        Structure is documented below.
        """
        return pulumi.get(self, "character_mask_config")

    @property
    @pulumi.getter(name="cryptoDeterministicConfig")
    def crypto_deterministic_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig']:
        """
        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")

    @property
    @pulumi.getter(name="cryptoReplaceFfxFpeConfig")
    def crypto_replace_ffx_fpe_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig']:
        """
        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")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "charactersToIgnores":
            suggest = "characters_to_ignores"
        elif key == "maskingCharacter":
            suggest = "masking_character"
        elif key == "numberToMask":
            suggest = "number_to_mask"
        elif key == "reverseOrder":
            suggest = "reverse_order"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 characters_to_ignores: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore']] = None,
                 masking_character: Optional[str] = None,
                 number_to_mask: Optional[int] = None,
                 reverse_order: Optional[bool] = None):
        """
        :param Sequence['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 str masking_character: is *
        :param int number_to_mask: is -4
        :param 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[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore']]:
        """
        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")

    @property
    @pulumi.getter(name="maskingCharacter")
    def masking_character(self) -> Optional[str]:
        """
        is *
        """
        return pulumi.get(self, "masking_character")

    @property
    @pulumi.getter(name="numberToMask")
    def number_to_mask(self) -> Optional[int]:
        """
        is -4
        """
        return pulumi.get(self, "number_to_mask")

    @property
    @pulumi.getter(name="reverseOrder")
    def reverse_order(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "charactersToSkip":
            suggest = "characters_to_skip"
        elif key == "commonCharactersToIgnore":
            suggest = "common_characters_to_ignore"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 characters_to_skip: Optional[str] = None,
                 common_characters_to_ignore: Optional[str] = None):
        """
        :param str characters_to_skip: Characters to not transform when masking.
        :param 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[str]:
        """
        Characters to not transform when masking.
        """
        return pulumi.get(self, "characters_to_skip")

    @property
    @pulumi.getter(name="commonCharactersToIgnore")
    def common_characters_to_ignore(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKey":
            suggest = "crypto_key"
        elif key == "surrogateInfoType":
            suggest = "surrogate_info_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 context: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContext'] = None,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey'] = None,
                 surrogate_info_type: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs' context: A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well.
               If the context is not set, plaintext would be used as is for encryption. If the context is set but:
               1. there is no record present when transforming a given value or
               2. the field is not present when transforming a given value,
               plaintext would be used as is for encryption.
               Note that case (1) is expected when an InfoTypeTransformation is applied to both structured and unstructured ContentItems.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs' crypto_key: The key used by the encryption function. For deterministic encryption using AES-SIV, the provided key is internally expanded to 64 bytes prior to use.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs' surrogate_info_type: The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate}
               For example, if the name of custom info type is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
               This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text.
               Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text.
               In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either
               *   reverse a surrogate that does not correspond to an actual identifier
               *   be unable to parse the surrogate and result in an error
               Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContext']:
        """
        A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well.
        If the context is not set, plaintext would be used as is for encryption. If the context is set but:
        1. there is no record present when transforming a given value or
        2. the field is not present when transforming a given value,
        plaintext would be used as is for encryption.
        Note that case (1) is expected when an InfoTypeTransformation is applied to both structured and unstructured ContentItems.
        Structure is documented below.
        """
        return pulumi.get(self, "context")

    @property
    @pulumi.getter(name="cryptoKey")
    def crypto_key(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey']:
        """
        The key used by the encryption function. For deterministic encryption using AES-SIV, the provided key is internally expanded to 64 bytes prior to use.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_key")

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType']:
        """
        The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate}
        For example, if the name of custom info type is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
        This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text.
        Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text.
        In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either
        *   reverse a surrogate that does not correspond to an actual identifier
        *   be unable to parse the surrogate and result in an error
        Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE.
        Structure is documented below.
        """
        return pulumi.get(self, "surrogate_info_type")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigContext(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param 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}`.
        :param str version: Optional version name for this InfoType.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> Optional[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")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Optional version name for this InfoType.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonAlphabet":
            suggest = "common_alphabet"
        elif key == "cryptoKey":
            suggest = "crypto_key"
        elif key == "customAlphabet":
            suggest = "custom_alphabet"
        elif key == "surrogateInfoType":
            suggest = "surrogate_info_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 common_alphabet: Optional[str] = None,
                 context: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext'] = None,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey'] = None,
                 custom_alphabet: Optional[str] = None,
                 radix: Optional[int] = None,
                 surrogate_info_type: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType'] = None):
        """
        :param str common_alphabet: Common alphabets.
               Possible values are `FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED`, `NUMERIC`, `HEXADECIMAL`, `UPPER_CASE_ALPHA_NUMERIC`, and `ALPHA_NUMERIC`.
        :param '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 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs' crypto_key: The key used by the encryption algorithm.
               Structure is documented below.
        :param 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 int radix: The native way to select the alphabet. Must be in the range \\[2, 95\\].
        :param '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[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")

    @property
    @pulumi.getter
    def context(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext']:
        """
        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")

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

    @property
    @pulumi.getter(name="customAlphabet")
    def custom_alphabet(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType']:
        """
        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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param 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}`.
        :param str version: Optional version name for this InfoType.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> Optional[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")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Optional version name for this InfoType.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "newValue":
            suggest = "new_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 new_value: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue'):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueArgs' new_value: Replace each input value with a given value.
               The `new_value` block must only contain one argument. For example when replacing the contents of a string-type field, only `string_value` should be set.
               Structure is documented below.
        """
        pulumi.set(__self__, "new_value", new_value)

    @property
    @pulumi.getter(name="newValue")
    def new_value(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue':
        """
        Replace each input value with a given value.
        The `new_value` block must only contain one argument. For example when replacing the contents of a string-type field, only `string_value` should be set.
        Structure is documented below.
        """
        return pulumi.get(self, "new_value")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[int] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param int integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigInfoTypeTransformationsTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fieldTransformations":
            suggest = "field_transformations"
        elif key == "recordSuppressions":
            suggest = "record_suppressions"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformations.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 field_transformations: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation']] = None,
                 record_suppressions: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppression']] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationArgs'] field_transformations: Transform the record by applying various field transformations.
               Structure is documented below.
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionArgs'] record_suppressions: Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.
               Structure is documented below.
        """
        if field_transformations is not None:
            pulumi.set(__self__, "field_transformations", field_transformations)
        if record_suppressions is not None:
            pulumi.set(__self__, "record_suppressions", record_suppressions)

    @property
    @pulumi.getter(name="fieldTransformations")
    def field_transformations(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation']]:
        """
        Transform the record by applying various field transformations.
        Structure is documented below.
        """
        return pulumi.get(self, "field_transformations")

    @property
    @pulumi.getter(name="recordSuppressions")
    def record_suppressions(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppression']]:
        """
        Configuration defining which records get suppressed entirely. Records that match any suppression rule are omitted from the output.
        Structure is documented below.
        """
        return pulumi.get(self, "record_suppressions")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "primitiveTransformation":
            suggest = "primitive_transformation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fields: Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationField'],
                 primitive_transformation: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation',
                 condition: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationCondition'] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationFieldArgs'] fields: Input field(s) to apply the transformation to. When you have columns that reference their position within a list, omit the index from the FieldId.
               FieldId name matching ignores the index. For example, instead of "contact.nums[0].type", use "contact.nums.type".
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationArgs' primitive_transformation: Apply the transformation to the entire field.
               The `primitive_transformation` block must only contain one argument, corresponding to the type of transformation.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionArgs' condition: Only apply the transformation if the condition evaluates to true for the given RecordCondition. The conditions are allowed to reference fields that are not used in the actual transformation.
               Example Use Cases:
               - Apply a different bucket transformation to an age column if the zip code column for the same record is within a specific range.
               - Redact a field if the date of birth field is greater than 85.
               Structure is documented below.
        """
        pulumi.set(__self__, "fields", fields)
        pulumi.set(__self__, "primitive_transformation", primitive_transformation)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter
    def fields(self) -> Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationField']:
        """
        Input field(s) to apply the transformation to. When you have columns that reference their position within a list, omit the index from the FieldId.
        FieldId name matching ignores the index. For example, instead of "contact.nums[0].type", use "contact.nums.type".
        Structure is documented below.
        """
        return pulumi.get(self, "fields")

    @property
    @pulumi.getter(name="primitiveTransformation")
    def primitive_transformation(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation':
        """
        Apply the transformation to the entire field.
        The `primitive_transformation` block must only contain one argument, corresponding to the type of transformation.
        Structure is documented below.
        """
        return pulumi.get(self, "primitive_transformation")

    @property
    @pulumi.getter
    def condition(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationCondition']:
        """
        Only apply the transformation if the condition evaluates to true for the given RecordCondition. The conditions are allowed to reference fields that are not used in the actual transformation.
        Example Use Cases:
        - Apply a different bucket transformation to an age column if the zip code column for the same record is within a specific range.
        - Redact a field if the date of birth field is greater than 85.
        Structure is documented below.
        """
        return pulumi.get(self, "condition")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationCondition(dict):
    def __init__(__self__, *,
                 expressions: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsArgs' expressions: An expression, consisting of an operator and conditions.
               Structure is documented below.
        """
        if expressions is not None:
            pulumi.set(__self__, "expressions", expressions)

    @property
    @pulumi.getter
    def expressions(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions']:
        """
        An expression, consisting of an operator and conditions.
        Structure is documented below.
        """
        return pulumi.get(self, "expressions")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logicalOperator":
            suggest = "logical_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 conditions: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditions'] = None,
                 logical_operator: Optional[str] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsArgs' conditions: Conditions to apply to the expression.
               Structure is documented below.
        :param str logical_operator: The operator to apply to the result of conditions. Default and currently only supported value is AND.
               Default value is `AND`.
               Possible values are `AND`.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if logical_operator is not None:
            pulumi.set(__self__, "logical_operator", logical_operator)

    @property
    @pulumi.getter
    def conditions(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditions']:
        """
        Conditions to apply to the expression.
        Structure is documented below.
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter(name="logicalOperator")
    def logical_operator(self) -> Optional[str]:
        """
        The operator to apply to the result of conditions. Default and currently only supported value is AND.
        Default value is `AND`.
        Possible values are `AND`.
        """
        return pulumi.get(self, "logical_operator")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditions(dict):
    def __init__(__self__, *,
                 conditions: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsCondition']] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionArgs'] conditions: A collection of conditions.
               Structure is documented below.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsCondition']]:
        """
        A collection of conditions.
        Structure is documented below.
        """
        return pulumi.get(self, "conditions")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsCondition(dict):
    def __init__(__self__, *,
                 field: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionField',
                 operator: str,
                 value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionFieldArgs' field: Field within the record this condition is evaluated against.
               Structure is documented below.
        :param str operator: Operator used to compare the field or infoType to the value.
               Possible values are `EQUAL_TO`, `NOT_EQUAL_TO`, `GREATER_THAN`, `LESS_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN_OR_EQUALS`, and `EXISTS`.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueArgs' value: Value to compare against. [Mandatory, except for EXISTS tests.]
               Structure is documented below.
        """
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def field(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionField':
        """
        Field within the record this condition is evaluated against.
        Structure is documented below.
        """
        return pulumi.get(self, "field")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Operator used to compare the field or infoType to the value.
        Possible values are `EQUAL_TO`, `NOT_EQUAL_TO`, `GREATER_THAN`, `LESS_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN_OR_EQUALS`, and `EXISTS`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue']:
        """
        Value to compare against. [Mandatory, except for EXISTS tests.]
        Structure is documented below.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationConditionExpressionsConditionsConditionValueTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketingConfig":
            suggest = "bucketing_config"
        elif key == "characterMaskConfig":
            suggest = "character_mask_config"
        elif key == "cryptoDeterministicConfig":
            suggest = "crypto_deterministic_config"
        elif key == "cryptoHashConfig":
            suggest = "crypto_hash_config"
        elif key == "cryptoReplaceFfxFpeConfig":
            suggest = "crypto_replace_ffx_fpe_config"
        elif key == "dateShiftConfig":
            suggest = "date_shift_config"
        elif key == "fixedSizeBucketingConfig":
            suggest = "fixed_size_bucketing_config"
        elif key == "redactConfig":
            suggest = "redact_config"
        elif key == "replaceConfig":
            suggest = "replace_config"
        elif key == "replaceDictionaryConfig":
            suggest = "replace_dictionary_config"
        elif key == "timePartConfig":
            suggest = "time_part_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucketing_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfig'] = None,
                 character_mask_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig'] = None,
                 crypto_deterministic_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig'] = None,
                 crypto_hash_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig'] = None,
                 crypto_replace_ffx_fpe_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig'] = None,
                 date_shift_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig'] = None,
                 fixed_size_bucketing_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig'] = None,
                 redact_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationRedactConfig'] = None,
                 replace_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig'] = None,
                 replace_dictionary_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig'] = None,
                 time_part_config: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigArgs' bucketing_config: Generalization function that buckets values based on ranges. The ranges and replacement values are dynamically provided by the user for custom behavior, such as 1-30 > LOW 31-65 > MEDIUM 66-100 > HIGH
               This can be used on data of type: number, long, string, timestamp.
               If the provided value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing.
               See https://cloud.google.com/dlp/docs/concepts-bucketing to learn more.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigArgs' 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. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigArgs' 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 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigArgs' crypto_hash_config: Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. The key size must be either 32 or 64 bytes.
               Outputs a base64 encoded representation of the hashed output (for example, L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=).
               Currently, only string and integer values can be hashed.
               See https://cloud.google.com/dlp/docs/pseudonymization to learn more.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigArgs' 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 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigArgs' date_shift_config: Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigArgs' fixed_size_bucketing_config: Buckets values based on fixed size ranges. The Bucketing transformation can provide all of this functionality, but requires more configuration. This message is provided as a convenience to the user for simple bucketing strategies.
               The transformed value will be a hyphenated string of {lower_bound}-{upper_bound}. For example, if lower_bound = 10 and upper_bound = 20, all values that are within this bucket will be replaced with "10-20".
               This can be used on data of type: double, long.
               If the bound Value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing.
               See https://cloud.google.com/dlp/docs/concepts-bucketing to learn more.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationRedactConfigArgs' redact_config: Redact a given value. For example, if used with an InfoTypeTransformation transforming PHONE_NUMBER, and input 'My phone number is 206-555-0123', the output would be 'My phone number is '.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigArgs' replace_config: Replace with a specified value.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigArgs' replace_dictionary_config: Replace with a value randomly drawn (with replacement) from a dictionary.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfigArgs' time_part_config: For use with Date, Timestamp, and TimeOfDay, extract or preserve a portion of the value.
               Structure is documented below.
        """
        if bucketing_config is not None:
            pulumi.set(__self__, "bucketing_config", bucketing_config)
        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_hash_config is not None:
            pulumi.set(__self__, "crypto_hash_config", crypto_hash_config)
        if crypto_replace_ffx_fpe_config is not None:
            pulumi.set(__self__, "crypto_replace_ffx_fpe_config", crypto_replace_ffx_fpe_config)
        if date_shift_config is not None:
            pulumi.set(__self__, "date_shift_config", date_shift_config)
        if fixed_size_bucketing_config is not None:
            pulumi.set(__self__, "fixed_size_bucketing_config", fixed_size_bucketing_config)
        if redact_config is not None:
            pulumi.set(__self__, "redact_config", redact_config)
        if replace_config is not None:
            pulumi.set(__self__, "replace_config", replace_config)
        if replace_dictionary_config is not None:
            pulumi.set(__self__, "replace_dictionary_config", replace_dictionary_config)
        if time_part_config is not None:
            pulumi.set(__self__, "time_part_config", time_part_config)

    @property
    @pulumi.getter(name="bucketingConfig")
    def bucketing_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfig']:
        """
        Generalization function that buckets values based on ranges. The ranges and replacement values are dynamically provided by the user for custom behavior, such as 1-30 > LOW 31-65 > MEDIUM 66-100 > HIGH
        This can be used on data of type: number, long, string, timestamp.
        If the provided value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing.
        See https://cloud.google.com/dlp/docs/concepts-bucketing to learn more.
        Structure is documented below.
        """
        return pulumi.get(self, "bucketing_config")

    @property
    @pulumi.getter(name="characterMaskConfig")
    def character_mask_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig']:
        """
        Partially mask a string by replacing a given number of characters with a fixed character. Masking can start from the beginning or end of the string. This can be used on data of any type (numbers, longs, and so on) and when de-identifying structured data we'll attempt to preserve the original data's type. (This allows you to take a long like 123 and modify it to a string like **3).
        Structure is documented below.
        """
        return pulumi.get(self, "character_mask_config")

    @property
    @pulumi.getter(name="cryptoDeterministicConfig")
    def crypto_deterministic_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig']:
        """
        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")

    @property
    @pulumi.getter(name="cryptoHashConfig")
    def crypto_hash_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig']:
        """
        Pseudonymization method that generates surrogates via cryptographic hashing. Uses SHA-256. The key size must be either 32 or 64 bytes.
        Outputs a base64 encoded representation of the hashed output (for example, L7k0BHmF1ha5U3NfGykjro4xWi1MPVQPjhMAZbSV9mM=).
        Currently, only string and integer values can be hashed.
        See https://cloud.google.com/dlp/docs/pseudonymization to learn more.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_hash_config")

    @property
    @pulumi.getter(name="cryptoReplaceFfxFpeConfig")
    def crypto_replace_ffx_fpe_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig']:
        """
        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")

    @property
    @pulumi.getter(name="dateShiftConfig")
    def date_shift_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig']:
        """
        Shifts dates by random number of days, with option to be consistent for the same context. See https://cloud.google.com/dlp/docs/concepts-date-shifting to learn more.
        Structure is documented below.
        """
        return pulumi.get(self, "date_shift_config")

    @property
    @pulumi.getter(name="fixedSizeBucketingConfig")
    def fixed_size_bucketing_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig']:
        """
        Buckets values based on fixed size ranges. The Bucketing transformation can provide all of this functionality, but requires more configuration. This message is provided as a convenience to the user for simple bucketing strategies.
        The transformed value will be a hyphenated string of {lower_bound}-{upper_bound}. For example, if lower_bound = 10 and upper_bound = 20, all values that are within this bucket will be replaced with "10-20".
        This can be used on data of type: double, long.
        If the bound Value type differs from the type of data being transformed, we will first attempt converting the type of the data to be transformed to match the type of the bound before comparing.
        See https://cloud.google.com/dlp/docs/concepts-bucketing to learn more.
        Structure is documented below.
        """
        return pulumi.get(self, "fixed_size_bucketing_config")

    @property
    @pulumi.getter(name="redactConfig")
    def redact_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationRedactConfig']:
        """
        Redact a given value. For example, if used with an InfoTypeTransformation transforming PHONE_NUMBER, and input 'My phone number is 206-555-0123', the output would be 'My phone number is '.
        """
        return pulumi.get(self, "redact_config")

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

    @property
    @pulumi.getter(name="replaceDictionaryConfig")
    def replace_dictionary_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig']:
        """
        Replace with a value randomly drawn (with replacement) from a dictionary.
        Structure is documented below.
        """
        return pulumi.get(self, "replace_dictionary_config")

    @property
    @pulumi.getter(name="timePartConfig")
    def time_part_config(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig']:
        """
        For use with Date, Timestamp, and TimeOfDay, extract or preserve a portion of the value.
        Structure is documented below.
        """
        return pulumi.get(self, "time_part_config")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfig(dict):
    def __init__(__self__, *,
                 buckets: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket']] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketArgs'] buckets: Set of buckets. Ranges must be non-overlapping.
               Bucket is represented as a range, along with replacement values.
               Structure is documented below.
        """
        if buckets is not None:
            pulumi.set(__self__, "buckets", buckets)

    @property
    @pulumi.getter
    def buckets(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket']]:
        """
        Set of buckets. Ranges must be non-overlapping.
        Bucket is represented as a range, along with replacement values.
        Structure is documented below.
        """
        return pulumi.get(self, "buckets")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "replacementValue":
            suggest = "replacement_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucket.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 replacement_value: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue',
                 max: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax'] = None,
                 min: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueArgs' replacement_value: Replacement value for this bucket.
               The `replacement_value` block must only contain one argument.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxArgs' max: Upper bound of the range, exclusive; type must match min.
               The `max` block must only contain one argument. See the `bucketing_config` block description for more information about choosing a data type.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinArgs' min: Lower bound of the range, inclusive. Type should be the same as max if used.
               The `min` block must only contain one argument. See the `bucketing_config` block description for more information about choosing a data type.
               Structure is documented below.
        """
        pulumi.set(__self__, "replacement_value", replacement_value)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter(name="replacementValue")
    def replacement_value(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue':
        """
        Replacement value for this bucket.
        The `replacement_value` block must only contain one argument.
        Structure is documented below.
        """
        return pulumi.get(self, "replacement_value")

    @property
    @pulumi.getter
    def max(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax']:
        """
        Upper bound of the range, exclusive; type must match min.
        The `max` block must only contain one argument. See the `bucketing_config` block description for more information about choosing a data type.
        Structure is documented below.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin']:
        """
        Lower bound of the range, inclusive. Type should be the same as max if used.
        The `min` block must only contain one argument. See the `bucketing_config` block description for more information about choosing a data type.
        Structure is documented below.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMax.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMaxTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMin.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketMinTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationBucketingConfigBucketReplacementValueTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "charactersToIgnores":
            suggest = "characters_to_ignores"
        elif key == "maskingCharacter":
            suggest = "masking_character"
        elif key == "numberToMask":
            suggest = "number_to_mask"
        elif key == "reverseOrder":
            suggest = "reverse_order"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 characters_to_ignores: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore']] = None,
                 masking_character: Optional[str] = None,
                 number_to_mask: Optional[int] = None,
                 reverse_order: Optional[bool] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnoreArgs'] 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 str masking_character: is *
        :param int number_to_mask: is -4
        :param 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[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore']]:
        """
        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")

    @property
    @pulumi.getter(name="maskingCharacter")
    def masking_character(self) -> Optional[str]:
        """
        is *
        """
        return pulumi.get(self, "masking_character")

    @property
    @pulumi.getter(name="numberToMask")
    def number_to_mask(self) -> Optional[int]:
        """
        is -4
        """
        return pulumi.get(self, "number_to_mask")

    @property
    @pulumi.getter(name="reverseOrder")
    def reverse_order(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "charactersToSkip":
            suggest = "characters_to_skip"
        elif key == "commonCharactersToIgnore":
            suggest = "common_characters_to_ignore"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCharacterMaskConfigCharactersToIgnore.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 characters_to_skip: Optional[str] = None,
                 common_characters_to_ignore: Optional[str] = None):
        """
        :param str characters_to_skip: Characters to not transform when masking.
        :param 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[str]:
        """
        Characters to not transform when masking.
        """
        return pulumi.get(self, "characters_to_skip")

    @property
    @pulumi.getter(name="commonCharactersToIgnore")
    def common_characters_to_ignore(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKey":
            suggest = "crypto_key"
        elif key == "surrogateInfoType":
            suggest = "surrogate_info_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 context: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigContext'] = None,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey'] = None,
                 surrogate_info_type: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigContextArgs' context: A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well.
               If the context is not set, plaintext would be used as is for encryption. If the context is set but:
               1. there is no record present when transforming a given value or
               2. the field is not present when transforming a given value,
               plaintext would be used as is for encryption.
               Note that case (1) is expected when an InfoTypeTransformation is applied to both structured and unstructured ContentItems.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyArgs' crypto_key: The key used by the encryption function. For deterministic encryption using AES-SIV, the provided key is internally expanded to 64 bytes prior to use.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoTypeArgs' surrogate_info_type: The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate}
               For example, if the name of custom info type is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
               This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text.
               Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text.
               In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either
               *   reverse a surrogate that does not correspond to an actual identifier
               *   be unable to parse the surrogate and result in an error
               Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigContext']:
        """
        A context may be used for higher security and maintaining referential integrity such that the same identifier in two different contexts will be given a distinct surrogate. The context is appended to plaintext value being encrypted. On decryption the provided context is validated against the value used during encryption. If a context was provided during encryption, same context must be provided during decryption as well.
        If the context is not set, plaintext would be used as is for encryption. If the context is set but:
        1. there is no record present when transforming a given value or
        2. the field is not present when transforming a given value,
        plaintext would be used as is for encryption.
        Note that case (1) is expected when an InfoTypeTransformation is applied to both structured and unstructured ContentItems.
        Structure is documented below.
        """
        return pulumi.get(self, "context")

    @property
    @pulumi.getter(name="cryptoKey")
    def crypto_key(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey']:
        """
        The key used by the encryption function. For deterministic encryption using AES-SIV, the provided key is internally expanded to 64 bytes prior to use.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_key")

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType']:
        """
        The custom info type to annotate the surrogate with. This annotation will be applied to the surrogate by prefixing it with the name of the custom info type followed by the number of characters comprising the surrogate. The following scheme defines the format: {info type name}({surrogate character count}):{surrogate}
        For example, if the name of custom info type is 'MY\\_TOKEN\\_INFO\\_TYPE' and the surrogate is 'abc', the full replacement value will be: 'MY\\_TOKEN\\_INFO\\_TYPE(3):abc'
        This annotation identifies the surrogate when inspecting content using the custom info type 'Surrogate'. This facilitates reversal of the surrogate when it occurs in free text.
        Note: For record transformations where the entire cell in a table is being transformed, surrogates are not mandatory. Surrogates are used to denote the location of the token and are necessary for re-identification in free form text.
        In order for inspection to work properly, the name of this info type must not occur naturally anywhere in your data; otherwise, inspection may either
        *   reverse a surrogate that does not correspond to an actual identifier
        *   be unable to parse the surrogate and result in an error
        Therefore, choose your custom info type name carefully after considering what your data looks like. One way to select a name that has a high chance of yielding reliable detection is to include one or more unicode characters that are highly improbable to exist in your data. For example, assuming your data is entered from a regular ASCII keyboard, the symbol with the hex code point 29DD might be used like so: ⧝MY\\_TOKEN\\_TYPE.
        Structure is documented below.
        """
        return pulumi.get(self, "surrogate_info_type")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigContext(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoDeterministicConfigSurrogateInfoType(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param 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}`.
        :param str version: Optional version name for this InfoType.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> Optional[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")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Optional version name for this InfoType.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKey":
            suggest = "crypto_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyArgs' crypto_key: The key used by the encryption function.
               Structure is documented below.
        """
        if crypto_key is not None:
            pulumi.set(__self__, "crypto_key", crypto_key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoHashConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonAlphabet":
            suggest = "common_alphabet"
        elif key == "cryptoKey":
            suggest = "crypto_key"
        elif key == "customAlphabet":
            suggest = "custom_alphabet"
        elif key == "surrogateInfoType":
            suggest = "surrogate_info_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 common_alphabet: Optional[str] = None,
                 context: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext'] = None,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey'] = None,
                 custom_alphabet: Optional[str] = None,
                 radix: Optional[int] = None,
                 surrogate_info_type: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType'] = None):
        """
        :param str common_alphabet: Common alphabets.
               Possible values are `FFX_COMMON_NATIVE_ALPHABET_UNSPECIFIED`, `NUMERIC`, `HEXADECIMAL`, `UPPER_CASE_ALPHA_NUMERIC`, and `ALPHA_NUMERIC`.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContextArgs' 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 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyArgs' crypto_key: The key used by the encryption algorithm.
               Structure is documented below.
        :param 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 int radix: The native way to select the alphabet. Must be in the range \\[2, 95\\].
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoTypeArgs' 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[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")

    @property
    @pulumi.getter
    def context(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext']:
        """
        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")

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

    @property
    @pulumi.getter(name="customAlphabet")
    def custom_alphabet(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="surrogateInfoType")
    def surrogate_info_type(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType']:
        """
        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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigContext(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationCryptoReplaceFfxFpeConfigSurrogateInfoType(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param 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}`.
        :param str version: Optional version name for this InfoType.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> Optional[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")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Optional version name for this InfoType.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lowerBoundDays":
            suggest = "lower_bound_days"
        elif key == "upperBoundDays":
            suggest = "upper_bound_days"
        elif key == "cryptoKey":
            suggest = "crypto_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 lower_bound_days: int,
                 upper_bound_days: int,
                 context: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigContext'] = None,
                 crypto_key: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey'] = None):
        """
        :param int lower_bound_days: For example, -5 means shift date to at most 5 days back in the past.
        :param int upper_bound_days: Range of shift in days. Actual shift will be selected at random within this range (inclusive ends). Negative means shift to earlier in time. Must not be more than 365250 days (1000 years) each direction.
               For example, 3 means shift date to at most 3 days into the future.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigContextArgs' context: Points to the field that contains the context, for example, an entity id.
               If set, must also set cryptoKey. If set, shift will be consistent for the given context.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyArgs' crypto_key: Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and cryptoKey. If set, must also set context. Can only be applied to table items.
               Structure is documented below.
        """
        pulumi.set(__self__, "lower_bound_days", lower_bound_days)
        pulumi.set(__self__, "upper_bound_days", upper_bound_days)
        if context is not None:
            pulumi.set(__self__, "context", context)
        if crypto_key is not None:
            pulumi.set(__self__, "crypto_key", crypto_key)

    @property
    @pulumi.getter(name="lowerBoundDays")
    def lower_bound_days(self) -> int:
        """
        For example, -5 means shift date to at most 5 days back in the past.
        """
        return pulumi.get(self, "lower_bound_days")

    @property
    @pulumi.getter(name="upperBoundDays")
    def upper_bound_days(self) -> int:
        """
        Range of shift in days. Actual shift will be selected at random within this range (inclusive ends). Negative means shift to earlier in time. Must not be more than 365250 days (1000 years) each direction.
        For example, 3 means shift date to at most 3 days into the future.
        """
        return pulumi.get(self, "upper_bound_days")

    @property
    @pulumi.getter
    def context(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigContext']:
        """
        Points to the field that contains the context, for example, an entity id.
        If set, must also set cryptoKey. If set, shift will be consistent for the given context.
        Structure is documented below.
        """
        return pulumi.get(self, "context")

    @property
    @pulumi.getter(name="cryptoKey")
    def crypto_key(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey']:
        """
        Causes the shift to be computed based on this key and the context. This results in the same shift for the same context and cryptoKey. If set, must also set context. Can only be applied to table items.
        Structure is documented below.
        """
        return pulumi.get(self, "crypto_key")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigContext(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsWrapped":
            suggest = "kms_wrapped"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_wrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped'] = None,
                 transient: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyTransient'] = None,
                 unwrapped: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyUnwrapped'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrappedArgs' kms_wrapped: KMS wrapped key.
               Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
               For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
               Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyTransientArgs' transient: Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyUnwrappedArgs' unwrapped: Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
               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['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped']:
        """
        KMS wrapped key.
        Include to use an existing data crypto key wrapped by KMS. The wrapped key must be a 128-, 192-, or 256-bit key. Authorization requires the following IAM permissions when sending a request to perform a crypto transformation using a KMS-wrapped crypto key: dlp.kms.encrypt
        For more information, see [Creating a wrapped key](https://cloud.google.com/dlp/docs/create-wrapped-key).
        Note: When you use Cloud KMS for cryptographic operations, [charges apply](https://cloud.google.com/kms/pricing).
        Structure is documented below.
        """
        return pulumi.get(self, "kms_wrapped")

    @property
    @pulumi.getter
    def transient(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyTransient']:
        """
        Transient crypto key. Use this to have a random data crypto key generated. It will be discarded after the request finishes.
        Structure is documented below.
        """
        return pulumi.get(self, "transient")

    @property
    @pulumi.getter
    def unwrapped(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyUnwrapped']:
        """
        Unwrapped crypto key. Using raw keys is prone to security risks due to accidentally leaking the key. Choose another type of key if possible.
        Structure is documented below.
        """
        return pulumi.get(self, "unwrapped")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cryptoKeyName":
            suggest = "crypto_key_name"
        elif key == "wrappedKey":
            suggest = "wrapped_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyKmsWrapped.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crypto_key_name: str,
                 wrapped_key: str):
        """
        :param str crypto_key_name: The resource name of the KMS CryptoKey to use for unwrapping.
        :param 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) -> str:
        """
        The resource name of the KMS CryptoKey to use for unwrapping.
        """
        return pulumi.get(self, "crypto_key_name")

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyTransient(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the key. This is an arbitrary string used to differentiate different keys. A unique key is generated per name: two separate `TransientCryptoKey` protos share the same generated key if their names are the same. When the data crypto key is generated, this name is not used in any way (repeating the api call will result in a different key being generated).
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationDateShiftConfigCryptoKeyUnwrapped(dict):
    def __init__(__self__, *,
                 key: str):
        """
        :param str key: A 128/192/256 bit key.
               A base64-encoded string.
        """
        pulumi.set(__self__, "key", key)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketSize":
            suggest = "bucket_size"
        elif key == "lowerBound":
            suggest = "lower_bound"
        elif key == "upperBound":
            suggest = "upper_bound"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_size: float,
                 lower_bound: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound',
                 upper_bound: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound'):
        """
        :param float bucket_size: Size of each bucket (except for minimum and maximum buckets).
               So if lower_bound = 10, upper_bound = 89, and bucketSize = 10, then the following buckets would be used: -10, 10-20, 20-30, 30-40, 40-50, 50-60, 60-70, 70-80, 80-89, 89+.
               Precision up to 2 decimals works.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundArgs' lower_bound: Lower bound value of buckets.
               All values less than lower_bound are grouped together into a single bucket; for example if lower_bound = 10, then all values less than 10 are replaced with the value "-10".
               The `lower_bound` block must only contain one argument. See the `fixed_size_bucketing_config` block description for more information about choosing a data type.
               Structure is documented below.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundArgs' upper_bound: Upper bound value of buckets.
               All values greater than upper_bound are grouped together into a single bucket; for example if upper_bound = 89, then all values greater than 89 are replaced with the value "89+".
               The `upper_bound` block must only contain one argument. See the `fixed_size_bucketing_config` block description for more information about choosing a data type.
               Structure is documented below.
        """
        pulumi.set(__self__, "bucket_size", bucket_size)
        pulumi.set(__self__, "lower_bound", lower_bound)
        pulumi.set(__self__, "upper_bound", upper_bound)

    @property
    @pulumi.getter(name="bucketSize")
    def bucket_size(self) -> float:
        """
        Size of each bucket (except for minimum and maximum buckets).
        So if lower_bound = 10, upper_bound = 89, and bucketSize = 10, then the following buckets would be used: -10, 10-20, 20-30, 30-40, 40-50, 50-60, 60-70, 70-80, 80-89, 89+.
        Precision up to 2 decimals works.
        """
        return pulumi.get(self, "bucket_size")

    @property
    @pulumi.getter(name="lowerBound")
    def lower_bound(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound':
        """
        Lower bound value of buckets.
        All values less than lower_bound are grouped together into a single bucket; for example if lower_bound = 10, then all values less than 10 are replaced with the value "-10".
        The `lower_bound` block must only contain one argument. See the `fixed_size_bucketing_config` block description for more information about choosing a data type.
        Structure is documented below.
        """
        return pulumi.get(self, "lower_bound")

    @property
    @pulumi.getter(name="upperBound")
    def upper_bound(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound':
        """
        Upper bound value of buckets.
        All values greater than upper_bound are grouped together into a single bucket; for example if upper_bound = 89, then all values greater than 89 are replaced with the value "89+".
        The `upper_bound` block must only contain one argument. See the `fixed_size_bucketing_config` block description for more information about choosing a data type.
        Structure is documented below.
        """
        return pulumi.get(self, "upper_bound")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBound.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigLowerBoundTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBound.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationFixedSizeBucketingConfigUpperBoundTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationRedactConfig(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "newValue":
            suggest = "new_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 new_value: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue'):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueArgs' new_value: Replace each input value with a given value.
               The `new_value` block must only contain one argument. For example when replacing the contents of a string-type field, only `string_value` should be set.
               Structure is documented below.
        """
        pulumi.set(__self__, "new_value", new_value)

    @property
    @pulumi.getter(name="newValue")
    def new_value(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue':
        """
        Replace each input value with a given value.
        The `new_value` block must only contain one argument. For example when replacing the contents of a string-type field, only `string_value` should be set.
        Structure is documented below.
        """
        return pulumi.get(self, "new_value")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceConfigNewValueTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "wordList":
            suggest = "word_list"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 word_list: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigWordList'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigWordListArgs' word_list: A list of words to select from for random replacement. The [limits](https://cloud.google.com/dlp/limits) page contains details about the size limits of dictionaries.
               Structure is documented below.
        """
        if word_list is not None:
            pulumi.set(__self__, "word_list", word_list)

    @property
    @pulumi.getter(name="wordList")
    def word_list(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigWordList']:
        """
        A list of words to select from for random replacement. The [limits](https://cloud.google.com/dlp/limits) page contains details about the size limits of dictionaries.
        Structure is documented below.
        """
        return pulumi.get(self, "word_list")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationReplaceDictionaryConfigWordList(dict):
    def __init__(__self__, *,
                 words: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "partToExtract":
            suggest = "part_to_extract"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsFieldTransformationPrimitiveTransformationTimePartConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 part_to_extract: Optional[str] = None):
        """
        :param str part_to_extract: The part of the time to keep.
               Possible values are `YEAR`, `MONTH`, `DAY_OF_MONTH`, `DAY_OF_WEEK`, `WEEK_OF_YEAR`, and `HOUR_OF_DAY`.
        """
        if part_to_extract is not None:
            pulumi.set(__self__, "part_to_extract", part_to_extract)

    @property
    @pulumi.getter(name="partToExtract")
    def part_to_extract(self) -> Optional[str]:
        """
        The part of the time to keep.
        Possible values are `YEAR`, `MONTH`, `DAY_OF_MONTH`, `DAY_OF_WEEK`, `WEEK_OF_YEAR`, and `HOUR_OF_DAY`.
        """
        return pulumi.get(self, "part_to_extract")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppression(dict):
    def __init__(__self__, *,
                 condition: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionCondition'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionArgs' condition: A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.
               Structure is documented below.
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionCondition']:
        """
        A condition that when it evaluates to true will result in the record being evaluated to be suppressed from the transformed content.
        Structure is documented below.
        """
        return pulumi.get(self, "condition")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionCondition(dict):
    def __init__(__self__, *,
                 expressions: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsArgs' expressions: An expression, consisting of an operator and conditions.
               Structure is documented below.
        """
        if expressions is not None:
            pulumi.set(__self__, "expressions", expressions)

    @property
    @pulumi.getter
    def expressions(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions']:
        """
        An expression, consisting of an operator and conditions.
        Structure is documented below.
        """
        return pulumi.get(self, "expressions")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logicalOperator":
            suggest = "logical_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 conditions: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditions'] = None,
                 logical_operator: Optional[str] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsArgs' conditions: Conditions to apply to the expression.
               Structure is documented below.
        :param str logical_operator: The operator to apply to the result of conditions. Default and currently only supported value is AND.
               Default value is `AND`.
               Possible values are `AND`.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if logical_operator is not None:
            pulumi.set(__self__, "logical_operator", logical_operator)

    @property
    @pulumi.getter
    def conditions(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditions']:
        """
        Conditions to apply to the expression.
        Structure is documented below.
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter(name="logicalOperator")
    def logical_operator(self) -> Optional[str]:
        """
        The operator to apply to the result of conditions. Default and currently only supported value is AND.
        Default value is `AND`.
        Possible values are `AND`.
        """
        return pulumi.get(self, "logical_operator")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditions(dict):
    def __init__(__self__, *,
                 conditions: Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsCondition']] = None):
        """
        :param Sequence['PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionArgs'] conditions: A collection of conditions.
               Structure is documented below.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[Sequence['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsCondition']]:
        """
        A collection of conditions.
        Structure is documented below.
        """
        return pulumi.get(self, "conditions")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsCondition(dict):
    def __init__(__self__, *,
                 field: 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionField',
                 operator: str,
                 value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue'] = None):
        """
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionFieldArgs' field: Field within the record this condition is evaluated against.
               Structure is documented below.
        :param str operator: Operator used to compare the field or infoType to the value.
               Possible values are `EQUAL_TO`, `NOT_EQUAL_TO`, `GREATER_THAN`, `LESS_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN_OR_EQUALS`, and `EXISTS`.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueArgs' value: Value to compare against. [Mandatory, except for EXISTS tests.]
               Structure is documented below.
        """
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def field(self) -> 'outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionField':
        """
        Field within the record this condition is evaluated against.
        Structure is documented below.
        """
        return pulumi.get(self, "field")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Operator used to compare the field or infoType to the value.
        Possible values are `EQUAL_TO`, `NOT_EQUAL_TO`, `GREATER_THAN`, `LESS_THAN`, `GREATER_THAN_OR_EQUALS`, `LESS_THAN_OR_EQUALS`, and `EXISTS`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue']:
        """
        Value to compare against. [Mandatory, except for EXISTS tests.]
        Structure is documented below.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None):
        """
        :param str name: Name describing the field.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "booleanValue":
            suggest = "boolean_value"
        elif key == "dateValue":
            suggest = "date_value"
        elif key == "dayOfWeekValue":
            suggest = "day_of_week_value"
        elif key == "floatValue":
            suggest = "float_value"
        elif key == "integerValue":
            suggest = "integer_value"
        elif key == "stringValue":
            suggest = "string_value"
        elif key == "timeValue":
            suggest = "time_value"
        elif key == "timestampValue":
            suggest = "timestamp_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValue.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 boolean_value: Optional[bool] = None,
                 date_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueDateValue'] = None,
                 day_of_week_value: Optional[str] = None,
                 float_value: Optional[float] = None,
                 integer_value: Optional[str] = None,
                 string_value: Optional[str] = None,
                 time_value: Optional['outputs.PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueTimeValue'] = None,
                 timestamp_value: Optional[str] = None):
        """
        :param bool boolean_value: A boolean value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueDateValueArgs' date_value: Represents a whole or partial calendar date.
               Structure is documented below.
        :param str day_of_week_value: Represents a day of the week.
               Possible values are `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, and `SUNDAY`.
        :param float float_value: A float value.
        :param str integer_value: An integer value (int64 format)
        :param str string_value: A string value.
        :param 'PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueTimeValueArgs' time_value: Represents a time of day.
               Structure is documented below.
        :param 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[bool]:
        """
        A boolean value.
        """
        return pulumi.get(self, "boolean_value")

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

    @property
    @pulumi.getter(name="dayOfWeekValue")
    def day_of_week_value(self) -> Optional[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")

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

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

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

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

    @property
    @pulumi.getter(name="timestampValue")
    def timestamp_value(self) -> Optional[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")


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueDateValue(dict):
    def __init__(__self__, *,
                 day: Optional[int] = None,
                 month: Optional[int] = None,
                 year: Optional[int] = None):
        """
        :param int day: Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        :param int month: Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
        :param int year: Year of the date. Must be from 1 to 9999, or 0 to specify 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[int]:
        """
        Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
        """
        return pulumi.get(self, "day")

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

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


@pulumi.output_type
class PreventionDeidentifyTemplateDeidentifyConfigRecordTransformationsRecordSuppressionConditionExpressionsConditionsConditionValueTimeValue(dict):
    def __init__(__self__, *,
                 hours: Optional[int] = None,
                 minutes: Optional[int] = None,
                 nanos: Optional[int] = None,
                 seconds: Optional[int] = None):
        """
        :param int hours: Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        :param int minutes: Minutes of hour of day. Must be from 0 to 59.
        :param int nanos: Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
        :param int seconds: Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        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[int]:
        """
        Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
        """
        return pulumi.get(self, "hours")

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

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

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        """
        Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
        """
        return pulumi.get(self, "seconds")


@pulumi.output_type
class PreventionInspectTemplateInspectConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentOptions":
            suggest = "content_options"
        elif key == "customInfoTypes":
            suggest = "custom_info_types"
        elif key == "excludeInfoTypes":
            suggest = "exclude_info_types"
        elif key == "includeQuote":
            suggest = "include_quote"
        elif key == "infoTypes":
            suggest = "info_types"
        elif key == "minLikelihood":
            suggest = "min_likelihood"
        elif key == "ruleSets":
            suggest = "rule_sets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 content_options: Optional[Sequence[str]] = None,
                 custom_info_types: Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigCustomInfoType']] = None,
                 exclude_info_types: Optional[bool] = None,
                 include_quote: Optional[bool] = None,
                 info_types: Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigInfoType']] = None,
                 limits: Optional['outputs.PreventionInspectTemplateInspectConfigLimits'] = None,
                 min_likelihood: Optional[str] = None,
                 rule_sets: Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSet']] = None):
        """
        :param Sequence[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 Sequence['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 bool exclude_info_types: When true, excludes type information of the findings.
        :param bool include_quote: When true, a contextual quote from the data that triggered a finding is included in the response.
        :param Sequence['PreventionInspectTemplateInspectConfigInfoTypeArgs'] info_types: Restricts what infoTypes to look for. The values must correspond to InfoType values returned by infoTypes.list
               or listed at https://cloud.google.com/dlp/docs/infotypes-reference.
               When no InfoTypes or CustomInfoTypes are specified in a request, the system may automatically choose what detectors to run.
               By default this may be all types, but may change over time as detectors are updated.
               Structure is documented below.
        :param 'PreventionInspectTemplateInspectConfigLimitsArgs' limits: Configuration to control the number of findings returned.
               Structure is documented below.
        :param 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 Sequence['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[Sequence[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")

    @property
    @pulumi.getter(name="customInfoTypes")
    def custom_info_types(self) -> Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigCustomInfoType']]:
        """
        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")

    @property
    @pulumi.getter(name="excludeInfoTypes")
    def exclude_info_types(self) -> Optional[bool]:
        """
        When true, excludes type information of the findings.
        """
        return pulumi.get(self, "exclude_info_types")

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

    @property
    @pulumi.getter(name="infoTypes")
    def info_types(self) -> Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigInfoType']]:
        """
        Restricts what infoTypes to look for. The values must correspond to InfoType values returned by infoTypes.list
        or listed at https://cloud.google.com/dlp/docs/infotypes-reference.
        When no InfoTypes or CustomInfoTypes are specified in a request, the system may automatically choose what detectors to run.
        By default this may be all types, but may change over time as detectors are updated.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

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

    @property
    @pulumi.getter(name="minLikelihood")
    def min_likelihood(self) -> Optional[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")

    @property
    @pulumi.getter(name="ruleSets")
    def rule_sets(self) -> Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSet']]:
        """
        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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "infoType":
            suggest = "info_type"
        elif key == "exclusionType":
            suggest = "exclusion_type"
        elif key == "storedType":
            suggest = "stored_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigCustomInfoType. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoType.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoType.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 info_type: 'outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeInfoType',
                 dictionary: Optional['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary'] = None,
                 exclusion_type: Optional[str] = None,
                 likelihood: Optional[str] = None,
                 regex: Optional['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeRegex'] = None,
                 stored_type: Optional['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeStoredType'] = None):
        """
        :param '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 'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryArgs' dictionary: Dictionary which defines the rule.
               Structure is documented below.
        :param 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 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 'PreventionInspectTemplateInspectConfigCustomInfoTypeRegexArgs' regex: Regular expression which defines the rule.
               Structure is documented below.
        :param '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) -> 'outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeInfoType':
        """
        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")

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

    @property
    @pulumi.getter(name="exclusionType")
    def exclusion_type(self) -> Optional[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")

    @property
    @pulumi.getter
    def likelihood(self) -> Optional[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")

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

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudStoragePath":
            suggest = "cloud_storage_path"
        elif key == "wordList":
            suggest = "word_list"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoTypeDictionary.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_storage_path: Optional['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePath'] = None,
                 word_list: Optional['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordList'] = None):
        """
        :param 'PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePathArgs' cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param '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['outputs.PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePath']:
        """
        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")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryCloudStoragePath(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param 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) -> str:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeDictionaryWordList(dict):
    def __init__(__self__, *,
                 words: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeInfoType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param 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 when specifying a built-in type.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> 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 when specifying a built-in type.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeRegex(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupIndexes":
            suggest = "group_indexes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigCustomInfoTypeRegex. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoTypeRegex.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigCustomInfoTypeRegex.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pattern: str,
                 group_indexes: Optional[Sequence[int]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[Sequence[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigCustomInfoTypeStoredType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param 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) -> str:
        """
        Resource name of the requested StoredInfoType, for example `organizations/433245324/storedInfoTypes/432452342`
        or `projects/project-id/storedInfoTypes/432452342`.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigInfoType(dict):
    def __init__(__self__, *,
                 name: str,
                 version: Optional[str] = None):
        """
        :param 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 when specifying a built-in type.
        :param str version: Version of the information type to use. By default, the version is set to stable
        """
        pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> 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 when specifying a built-in type.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Version of the information type to use. By default, the version is set to stable
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigLimits(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxFindingsPerItem":
            suggest = "max_findings_per_item"
        elif key == "maxFindingsPerRequest":
            suggest = "max_findings_per_request"
        elif key == "maxFindingsPerInfoTypes":
            suggest = "max_findings_per_info_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigLimits. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigLimits.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigLimits.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 max_findings_per_item: int,
                 max_findings_per_request: int,
                 max_findings_per_info_types: Optional[Sequence['outputs.PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType']] = None):
        """
        :param int max_findings_per_item: Max number of findings that will be returned for each item scanned. The maximum returned is 2000.
        :param int max_findings_per_request: Max number of findings that will be returned per request/job. The maximum returned is 2000.
        :param Sequence['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) -> 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")

    @property
    @pulumi.getter(name="maxFindingsPerRequest")
    def max_findings_per_request(self) -> 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")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "infoType":
            suggest = "info_type"
        elif key == "maxFindings":
            suggest = "max_findings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoType.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 info_type: 'outputs.PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoType',
                 max_findings: int):
        """
        :param 'PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeArgs' info_type: Type of information the findings limit applies to. Only one limit per infoType should be provided. If InfoTypeLimit does
               not have an infoType, the DLP API applies the limit against all infoTypes that are found but not
               specified in another InfoTypeLimit.
               Structure is documented below.
        :param 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) -> 'outputs.PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoType':
        """
        Type of information the findings limit applies to. Only one limit per infoType should be provided. If InfoTypeLimit does
        not have an infoType, the DLP API applies the limit against all infoTypes that are found but not
        specified in another InfoTypeLimit.
        Structure is documented below.
        """
        return pulumi.get(self, "info_type")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigLimitsMaxFindingsPerInfoTypeInfoType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param 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 when specifying a built-in type.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> 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 when specifying a built-in type.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "infoTypes":
            suggest = "info_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 info_types: Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSetInfoType'],
                 rules: Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSetRule']):
        """
        :param Sequence['PreventionInspectTemplateInspectConfigRuleSetInfoTypeArgs'] info_types: List of infoTypes this rule set is applied to.
               Structure is documented below.
        :param Sequence['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) -> Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSetInfoType']:
        """
        List of infoTypes this rule set is applied to.
        Structure is documented below.
        """
        return pulumi.get(self, "info_types")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetInfoType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param 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 when specifying a built-in type.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> 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 when specifying a built-in type.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exclusionRule":
            suggest = "exclusion_rule"
        elif key == "hotwordRule":
            suggest = "hotword_rule"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 exclusion_rule: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule'] = None,
                 hotword_rule: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule'] = None):
        """
        :param 'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleArgs' exclusion_rule: The rule that specifies conditions when findings of infoTypes specified in InspectionRuleSet are removed from results.
               Structure is documented below.
        :param '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['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule']:
        """
        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")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "matchingType":
            suggest = "matching_type"
        elif key == "excludeInfoTypes":
            suggest = "exclude_info_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 matching_type: str,
                 dictionary: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary'] = None,
                 exclude_info_types: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes'] = None,
                 regex: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex'] = None):
        """
        :param 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 'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryArgs' dictionary: Dictionary which defines the rule.
               Structure is documented below.
        :param 'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesArgs' exclude_info_types: Set of infoTypes for which findings would affect this rule.
               Structure is documented below.
        :param '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) -> 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")

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

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

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudStoragePath":
            suggest = "cloud_storage_path"
        elif key == "wordList":
            suggest = "word_list"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionary.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_storage_path: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePath'] = None,
                 word_list: Optional['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordList'] = None):
        """
        :param 'PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePathArgs' cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param '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['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePath']:
        """
        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")

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


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryCloudStoragePath(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param 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) -> str:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleDictionaryWordList(dict):
    def __init__(__self__, *,
                 words: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "infoTypes":
            suggest = "info_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypes.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 info_types: Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoType']):
        """
        :param Sequence['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) -> Sequence['outputs.PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoType']:
        """
        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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleExcludeInfoTypesInfoType(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param 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 when specifying a built-in type.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> 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 when specifying a built-in type.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupIndexes":
            suggest = "group_indexes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleExclusionRuleRegex.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pattern: str,
                 group_indexes: Optional[Sequence[int]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[Sequence[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hotwordRegex":
            suggest = "hotword_regex"
        elif key == "likelihoodAdjustment":
            suggest = "likelihood_adjustment"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hotword_regex: 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex',
                 likelihood_adjustment: 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment',
                 proximity: 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity'):
        """
        :param 'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs' hotword_regex: Regular expression pattern defining what qualifies as a hotword.
               Structure is documented below.
        :param 'PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs' likelihood_adjustment: Likelihood adjustment to apply to all matching findings.
               Structure is documented below.
        :param '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) -> 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex':
        """
        Regular expression pattern defining what qualifies as a hotword.
        Structure is documented below.
        """
        return pulumi.get(self, "hotword_regex")

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

    @property
    @pulumi.getter
    def proximity(self) -> 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity':
        """
        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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupIndexes":
            suggest = "group_indexes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegex.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pattern: str,
                 group_indexes: Optional[Sequence[int]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[Sequence[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedLikelihood":
            suggest = "fixed_likelihood"
        elif key == "relativeLikelihood":
            suggest = "relative_likelihood"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustment.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 fixed_likelihood: Optional[str] = None,
                 relative_likelihood: Optional[int] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="relativeLikelihood")
    def relative_likelihood(self) -> Optional[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")


@pulumi.output_type
class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "windowAfter":
            suggest = "window_after"
        elif key == "windowBefore":
            suggest = "window_before"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 window_after: Optional[int] = None,
                 window_before: Optional[int] = None):
        """
        :param int window_after: Number of characters after the finding to consider. Either this or window_before must be specified
        :param 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[int]:
        """
        Number of characters after the finding to consider. Either this or window_before must be specified
        """
        return pulumi.get(self, "window_after")

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


@pulumi.output_type
class PreventionJobTriggerInspectJob(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inspectTemplateName":
            suggest = "inspect_template_name"
        elif key == "storageConfig":
            suggest = "storage_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJob. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJob.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJob.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 actions: Sequence['outputs.PreventionJobTriggerInspectJobAction'],
                 inspect_template_name: str,
                 storage_config: 'outputs.PreventionJobTriggerInspectJobStorageConfig'):
        """
        :param Sequence['PreventionJobTriggerInspectJobActionArgs'] actions: A task to execute on the completion of a job.
               Structure is documented below.
        :param str inspect_template_name: The name of the template to run when this job is triggered.
        :param '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) -> Sequence['outputs.PreventionJobTriggerInspectJobAction']:
        """
        A task to execute on the completion of a job.
        Structure is documented below.
        """
        return pulumi.get(self, "actions")

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

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


@pulumi.output_type
class PreventionJobTriggerInspectJobAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pubSub":
            suggest = "pub_sub"
        elif key == "publishFindingsToCloudDataCatalog":
            suggest = "publish_findings_to_cloud_data_catalog"
        elif key == "publishSummaryToCscc":
            suggest = "publish_summary_to_cscc"
        elif key == "saveFindings":
            suggest = "save_findings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pub_sub: Optional['outputs.PreventionJobTriggerInspectJobActionPubSub'] = None,
                 publish_findings_to_cloud_data_catalog: Optional['outputs.PreventionJobTriggerInspectJobActionPublishFindingsToCloudDataCatalog'] = None,
                 publish_summary_to_cscc: Optional['outputs.PreventionJobTriggerInspectJobActionPublishSummaryToCscc'] = None,
                 save_findings: Optional['outputs.PreventionJobTriggerInspectJobActionSaveFindings'] = None):
        """
        :param 'PreventionJobTriggerInspectJobActionPubSubArgs' pub_sub: Publish a message into a given Pub/Sub topic when the job completes.
               Structure is documented below.
        :param 'PreventionJobTriggerInspectJobActionPublishFindingsToCloudDataCatalogArgs' publish_findings_to_cloud_data_catalog: Publish findings of a DlpJob to Data Catalog.
        :param 'PreventionJobTriggerInspectJobActionPublishSummaryToCsccArgs' publish_summary_to_cscc: Publish the result summary of a DlpJob to the Cloud Security Command Center.
        :param 'PreventionJobTriggerInspectJobActionSaveFindingsArgs' save_findings: If set, the detailed findings will be persisted to the specified OutputStorageConfig. Only a single instance of this action can be specified. Compatible with: Inspect, Risk
               Structure is documented below.
        """
        if pub_sub is not None:
            pulumi.set(__self__, "pub_sub", pub_sub)
        if publish_findings_to_cloud_data_catalog is not None:
            pulumi.set(__self__, "publish_findings_to_cloud_data_catalog", publish_findings_to_cloud_data_catalog)
        if publish_summary_to_cscc is not None:
            pulumi.set(__self__, "publish_summary_to_cscc", publish_summary_to_cscc)
        if save_findings is not None:
            pulumi.set(__self__, "save_findings", save_findings)

    @property
    @pulumi.getter(name="pubSub")
    def pub_sub(self) -> Optional['outputs.PreventionJobTriggerInspectJobActionPubSub']:
        """
        Publish a message into a given Pub/Sub topic when the job completes.
        Structure is documented below.
        """
        return pulumi.get(self, "pub_sub")

    @property
    @pulumi.getter(name="publishFindingsToCloudDataCatalog")
    def publish_findings_to_cloud_data_catalog(self) -> Optional['outputs.PreventionJobTriggerInspectJobActionPublishFindingsToCloudDataCatalog']:
        """
        Publish findings of a DlpJob to Data Catalog.
        """
        return pulumi.get(self, "publish_findings_to_cloud_data_catalog")

    @property
    @pulumi.getter(name="publishSummaryToCscc")
    def publish_summary_to_cscc(self) -> Optional['outputs.PreventionJobTriggerInspectJobActionPublishSummaryToCscc']:
        """
        Publish the result summary of a DlpJob to the Cloud Security Command Center.
        """
        return pulumi.get(self, "publish_summary_to_cscc")

    @property
    @pulumi.getter(name="saveFindings")
    def save_findings(self) -> Optional['outputs.PreventionJobTriggerInspectJobActionSaveFindings']:
        """
        If set, the detailed findings will be persisted to the specified OutputStorageConfig. Only a single instance of this action can be specified. Compatible with: Inspect, Risk
        Structure is documented below.
        """
        return pulumi.get(self, "save_findings")


@pulumi.output_type
class PreventionJobTriggerInspectJobActionPubSub(dict):
    def __init__(__self__, *,
                 topic: str):
        """
        :param str topic: Cloud Pub/Sub topic to send notifications to.
        """
        pulumi.set(__self__, "topic", topic)

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        Cloud Pub/Sub topic to send notifications to.
        """
        return pulumi.get(self, "topic")


@pulumi.output_type
class PreventionJobTriggerInspectJobActionPublishFindingsToCloudDataCatalog(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class PreventionJobTriggerInspectJobActionPublishSummaryToCscc(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class PreventionJobTriggerInspectJobActionSaveFindings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "outputConfig":
            suggest = "output_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobActionSaveFindings. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindings.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindings.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 output_config: 'outputs.PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig'):
        """
        :param '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) -> 'outputs.PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig':
        """
        Information on where to store output
        Structure is documented below.
        """
        return pulumi.get(self, "output_config")


@pulumi.output_type
class PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "outputSchema":
            suggest = "output_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindingsOutputConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 table: 'outputs.PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable',
                 output_schema: Optional[str] = None):
        """
        :param 'PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTableArgs' table: Information on the location of the target BigQuery Table.
               Structure is documented below.
        :param 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) -> 'outputs.PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable':
        """
        Information on the location of the target BigQuery Table.
        Structure is documented below.
        """
        return pulumi.get(self, "table")

    @property
    @pulumi.getter(name="outputSchema")
    def output_schema(self) -> Optional[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")


@pulumi.output_type
class PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datasetId":
            suggest = "dataset_id"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "tableId":
            suggest = "table_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobActionSaveFindingsOutputConfigTable.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dataset_id: str,
                 project_id: str,
                 table_id: Optional[str] = None):
        """
        :param str dataset_id: Dataset ID of the table.
        :param str project_id: The Google Cloud Platform project ID of the project containing the table.
        :param 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) -> str:
        """
        Dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

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

    @property
    @pulumi.getter(name="tableId")
    def table_id(self) -> Optional[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")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bigQueryOptions":
            suggest = "big_query_options"
        elif key == "cloudStorageOptions":
            suggest = "cloud_storage_options"
        elif key == "datastoreOptions":
            suggest = "datastore_options"
        elif key == "timespanConfig":
            suggest = "timespan_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 big_query_options: Optional['outputs.PreventionJobTriggerInspectJobStorageConfigBigQueryOptions'] = None,
                 cloud_storage_options: Optional['outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions'] = None,
                 datastore_options: Optional['outputs.PreventionJobTriggerInspectJobStorageConfigDatastoreOptions'] = None,
                 timespan_config: Optional['outputs.PreventionJobTriggerInspectJobStorageConfigTimespanConfig'] = None):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsArgs' big_query_options: Options defining BigQuery table and row identifiers.
               Structure is documented below.
        :param 'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsArgs' cloud_storage_options: Options defining a file or a set of files within a Google Cloud Storage bucket.
               Structure is documented below.
        :param 'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsArgs' datastore_options: Options defining a data set within Google Cloud Datastore.
               Structure is documented below.
        :param '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['outputs.PreventionJobTriggerInspectJobStorageConfigBigQueryOptions']:
        """
        Options defining BigQuery table and row identifiers.
        Structure is documented below.
        """
        return pulumi.get(self, "big_query_options")

    @property
    @pulumi.getter(name="cloudStorageOptions")
    def cloud_storage_options(self) -> Optional['outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions']:
        """
        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")

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

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


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigBigQueryOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tableReference":
            suggest = "table_reference"
        elif key == "identifyingFields":
            suggest = "identifying_fields"
        elif key == "rowsLimit":
            suggest = "rows_limit"
        elif key == "rowsLimitPercent":
            suggest = "rows_limit_percent"
        elif key == "sampleMethod":
            suggest = "sample_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigBigQueryOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigBigQueryOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigBigQueryOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 table_reference: 'outputs.PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference',
                 identifying_fields: Optional[Sequence['outputs.PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsIdentifyingField']] = None,
                 rows_limit: Optional[int] = None,
                 rows_limit_percent: Optional[int] = None,
                 sample_method: Optional[str] = None):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReferenceArgs' table_reference: Set of files to scan.
               Structure is documented below.
        :param Sequence['PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsIdentifyingFieldArgs'] identifying_fields: Specifies the BigQuery fields that will be returned with findings.
               If not specified, no identifying fields will be returned for findings.
               Structure is documented below.
        :param int rows_limit: Max number of rows to scan. If the table has more rows than this value, the rest of the rows are omitted.
               If not set, or if set to 0, all rows will be scanned. Only one of rowsLimit and rowsLimitPercent can be
               specified. Cannot be used in conjunction with TimespanConfig.
        :param int rows_limit_percent: Max percentage of rows to scan. The rest are omitted. The number of rows scanned is rounded down.
               Must be between 0 and 100, inclusively. Both 0 and 100 means no limit. Defaults to 0. Only one of
               rowsLimit and rowsLimitPercent can be specified. Cannot be used in conjunction with TimespanConfig.
        :param str sample_method: How to sample rows if not all rows are scanned. Meaningful only when used in conjunction with either
               rowsLimit or rowsLimitPercent. If not specified, rows are scanned in the order BigQuery reads them.
               Default value is `TOP`.
               Possible values are `TOP` and `RANDOM_START`.
        """
        pulumi.set(__self__, "table_reference", table_reference)
        if identifying_fields is not None:
            pulumi.set(__self__, "identifying_fields", identifying_fields)
        if rows_limit is not None:
            pulumi.set(__self__, "rows_limit", rows_limit)
        if rows_limit_percent is not None:
            pulumi.set(__self__, "rows_limit_percent", rows_limit_percent)
        if sample_method is not None:
            pulumi.set(__self__, "sample_method", sample_method)

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

    @property
    @pulumi.getter(name="identifyingFields")
    def identifying_fields(self) -> Optional[Sequence['outputs.PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsIdentifyingField']]:
        """
        Specifies the BigQuery fields that will be returned with findings.
        If not specified, no identifying fields will be returned for findings.
        Structure is documented below.
        """
        return pulumi.get(self, "identifying_fields")

    @property
    @pulumi.getter(name="rowsLimit")
    def rows_limit(self) -> Optional[int]:
        """
        Max number of rows to scan. If the table has more rows than this value, the rest of the rows are omitted.
        If not set, or if set to 0, all rows will be scanned. Only one of rowsLimit and rowsLimitPercent can be
        specified. Cannot be used in conjunction with TimespanConfig.
        """
        return pulumi.get(self, "rows_limit")

    @property
    @pulumi.getter(name="rowsLimitPercent")
    def rows_limit_percent(self) -> Optional[int]:
        """
        Max percentage of rows to scan. The rest are omitted. The number of rows scanned is rounded down.
        Must be between 0 and 100, inclusively. Both 0 and 100 means no limit. Defaults to 0. Only one of
        rowsLimit and rowsLimitPercent can be specified. Cannot be used in conjunction with TimespanConfig.
        """
        return pulumi.get(self, "rows_limit_percent")

    @property
    @pulumi.getter(name="sampleMethod")
    def sample_method(self) -> Optional[str]:
        """
        How to sample rows if not all rows are scanned. Meaningful only when used in conjunction with either
        rowsLimit or rowsLimitPercent. If not specified, rows are scanned in the order BigQuery reads them.
        Default value is `TOP`.
        Possible values are `TOP` and `RANDOM_START`.
        """
        return pulumi.get(self, "sample_method")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsIdentifyingField(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name of a BigQuery field to be returned with the findings.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of a BigQuery field to be returned with the findings.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datasetId":
            suggest = "dataset_id"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "tableId":
            suggest = "table_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigBigQueryOptionsTableReference.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dataset_id: str,
                 project_id: str,
                 table_id: str):
        """
        :param str dataset_id: The dataset ID of the table.
        :param str project_id: The Google Cloud Platform project ID of the project containing the table.
        :param 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) -> str:
        """
        The dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

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

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


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fileSet":
            suggest = "file_set"
        elif key == "bytesLimitPerFile":
            suggest = "bytes_limit_per_file"
        elif key == "bytesLimitPerFilePercent":
            suggest = "bytes_limit_per_file_percent"
        elif key == "fileTypes":
            suggest = "file_types"
        elif key == "filesLimitPercent":
            suggest = "files_limit_percent"
        elif key == "sampleMethod":
            suggest = "sample_method"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 file_set: 'outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet',
                 bytes_limit_per_file: Optional[int] = None,
                 bytes_limit_per_file_percent: Optional[int] = None,
                 file_types: Optional[Sequence[str]] = None,
                 files_limit_percent: Optional[int] = None,
                 sample_method: Optional[str] = None):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetArgs' file_set: Set of files to scan.
               Structure is documented below.
        :param 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 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 Sequence[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 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 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) -> 'outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet':
        """
        Set of files to scan.
        Structure is documented below.
        """
        return pulumi.get(self, "file_set")

    @property
    @pulumi.getter(name="bytesLimitPerFile")
    def bytes_limit_per_file(self) -> Optional[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")

    @property
    @pulumi.getter(name="bytesLimitPerFilePercent")
    def bytes_limit_per_file_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="fileTypes")
    def file_types(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="filesLimitPercent")
    def files_limit_percent(self) -> Optional[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")

    @property
    @pulumi.getter(name="sampleMethod")
    def sample_method(self) -> Optional[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")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "regexFileSet":
            suggest = "regex_file_set"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 regex_file_set: Optional['outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet'] = None,
                 url: Optional[str] = None):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSetArgs' regex_file_set: The regex-filtered set of files to scan.
               Structure is documented below.
        :param 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['outputs.PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet']:
        """
        The regex-filtered set of files to scan.
        Structure is documented below.
        """
        return pulumi.get(self, "regex_file_set")

    @property
    @pulumi.getter
    def url(self) -> Optional[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")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "excludeRegexes":
            suggest = "exclude_regexes"
        elif key == "includeRegexes":
            suggest = "include_regexes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigCloudStorageOptionsFileSetRegexFileSet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_name: str,
                 exclude_regexes: Optional[Sequence[str]] = None,
                 include_regexes: Optional[Sequence[str]] = None):
        """
        :param str bucket_name: The name of a Cloud Storage bucket.
        :param Sequence[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 Sequence[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) -> str:
        """
        The name of a Cloud Storage bucket.
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter(name="excludeRegexes")
    def exclude_regexes(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="includeRegexes")
    def include_regexes(self) -> Optional[Sequence[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")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "partitionId":
            suggest = "partition_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigDatastoreOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigDatastoreOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigDatastoreOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kind: 'outputs.PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKind',
                 partition_id: 'outputs.PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId'):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKindArgs' kind: A representation of a Datastore kind.
               Structure is documented below.
        :param '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) -> 'outputs.PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKind':
        """
        A representation of a Datastore kind.
        Structure is documented below.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter(name="partitionId")
    def partition_id(self) -> 'outputs.PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId':
        """
        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")


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsKind(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of the Datastore kind.
        """
        pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"
        elif key == "namespaceId":
            suggest = "namespace_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigDatastoreOptionsPartitionId.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 project_id: str,
                 namespace_id: Optional[str] = None):
        """
        :param str project_id: The ID of the project to which the entities belong.
        :param 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) -> str:
        """
        The ID of the project to which the entities belong.
        """
        return pulumi.get(self, "project_id")

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


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigTimespanConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timestampField":
            suggest = "timestamp_field"
        elif key == "enableAutoPopulationOfTimespanConfig":
            suggest = "enable_auto_population_of_timespan_config"
        elif key == "endTime":
            suggest = "end_time"
        elif key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerInspectJobStorageConfigTimespanConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerInspectJobStorageConfigTimespanConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerInspectJobStorageConfigTimespanConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 timestamp_field: 'outputs.PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampField',
                 enable_auto_population_of_timespan_config: Optional[bool] = None,
                 end_time: Optional[str] = None,
                 start_time: Optional[str] = None):
        """
        :param 'PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampFieldArgs' timestamp_field: Information on where to inspect
               Structure is documented below.
        :param 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 str end_time: Exclude files or rows newer than this value. If set to zero, no upper time limit is applied.
        :param 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) -> 'outputs.PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampField':
        """
        Information on where to inspect
        Structure is documented below.
        """
        return pulumi.get(self, "timestamp_field")

    @property
    @pulumi.getter(name="enableAutoPopulationOfTimespanConfig")
    def enable_auto_population_of_timespan_config(self) -> Optional[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")

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[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")

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


@pulumi.output_type
class PreventionJobTriggerInspectJobStorageConfigTimespanConfigTimestampField(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Specification of the field containing the timestamp of scanned items. Used for data sources like Datastore and BigQuery.
               For BigQuery: Required to filter out rows based on the given start and end times. If not specified and the table was
               modified between the given start and end times, the entire table will be scanned. The valid data types of the timestamp
               field are: INTEGER, DATE, TIMESTAMP, or DATETIME BigQuery column.
               For Datastore. Valid data types of the timestamp field are: TIMESTAMP. Datastore entity will be scanned if the
               timestamp property does not exist or its value is empty or invalid.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specification of the field containing the timestamp of scanned items. Used for data sources like Datastore and BigQuery.
        For BigQuery: Required to filter out rows based on the given start and end times. If not specified and the table was
        modified between the given start and end times, the entire table will be scanned. The valid data types of the timestamp
        field are: INTEGER, DATE, TIMESTAMP, or DATETIME BigQuery column.
        For Datastore. Valid data types of the timestamp field are: TIMESTAMP. Datastore entity will be scanned if the
        timestamp property does not exist or its value is empty or invalid.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PreventionJobTriggerTrigger(dict):
    def __init__(__self__, *,
                 schedule: Optional['outputs.PreventionJobTriggerTriggerSchedule'] = None):
        """
        :param '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['outputs.PreventionJobTriggerTriggerSchedule']:
        """
        Schedule for triggered jobs
        Structure is documented below.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class PreventionJobTriggerTriggerSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recurrencePeriodDuration":
            suggest = "recurrence_period_duration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionJobTriggerTriggerSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionJobTriggerTriggerSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionJobTriggerTriggerSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 recurrence_period_duration: Optional[str] = None):
        """
        :param 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[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")


@pulumi.output_type
class PreventionStoredInfoTypeDictionary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudStoragePath":
            suggest = "cloud_storage_path"
        elif key == "wordList":
            suggest = "word_list"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionStoredInfoTypeDictionary. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionStoredInfoTypeDictionary.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionStoredInfoTypeDictionary.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_storage_path: Optional['outputs.PreventionStoredInfoTypeDictionaryCloudStoragePath'] = None,
                 word_list: Optional['outputs.PreventionStoredInfoTypeDictionaryWordList'] = None):
        """
        :param 'PreventionStoredInfoTypeDictionaryCloudStoragePathArgs' cloud_storage_path: Newline-delimited file of words in Cloud Storage. Only a single file is accepted.
               Structure is documented below.
        :param '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['outputs.PreventionStoredInfoTypeDictionaryCloudStoragePath']:
        """
        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")

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


@pulumi.output_type
class PreventionStoredInfoTypeDictionaryCloudStoragePath(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param 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) -> str:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PreventionStoredInfoTypeDictionaryWordList(dict):
    def __init__(__self__, *,
                 words: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "outputPath":
            suggest = "output_path"
        elif key == "bigQueryField":
            suggest = "big_query_field"
        elif key == "cloudStorageFileSet":
            suggest = "cloud_storage_file_set"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionStoredInfoTypeLargeCustomDictionary. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionStoredInfoTypeLargeCustomDictionary.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionStoredInfoTypeLargeCustomDictionary.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 output_path: 'outputs.PreventionStoredInfoTypeLargeCustomDictionaryOutputPath',
                 big_query_field: Optional['outputs.PreventionStoredInfoTypeLargeCustomDictionaryBigQueryField'] = None,
                 cloud_storage_file_set: Optional['outputs.PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSet'] = None):
        """
        :param '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 'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldArgs' big_query_field: Field in a BigQuery table where each cell represents a dictionary phrase.
               Structure is documented below.
        :param '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) -> 'outputs.PreventionStoredInfoTypeLargeCustomDictionaryOutputPath':
        """
        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")

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

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


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryField(dict):
    def __init__(__self__, *,
                 field: 'outputs.PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldField',
                 table: 'outputs.PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable'):
        """
        :param 'PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldFieldArgs' field: Designated field in the BigQuery table.
               Structure is documented below.
        :param '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) -> 'outputs.PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldField':
        """
        Designated field in the BigQuery table.
        Structure is documented below.
        """
        return pulumi.get(self, "field")

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


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldField(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Name describing the field.
        """
        pulumi.set(__self__, "name", name)

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


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datasetId":
            suggest = "dataset_id"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "tableId":
            suggest = "table_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionStoredInfoTypeLargeCustomDictionaryBigQueryFieldTable.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dataset_id: str,
                 project_id: str,
                 table_id: str):
        """
        :param str dataset_id: The dataset ID of the table.
        :param str project_id: The Google Cloud Platform project ID of the project containing the table.
        :param 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) -> str:
        """
        The dataset ID of the table.
        """
        return pulumi.get(self, "dataset_id")

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

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


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionaryCloudStorageFileSet(dict):
    def __init__(__self__, *,
                 url: str):
        """
        :param 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) -> str:
        """
        The url, in the format `gs://<bucket>/<path>`. Trailing wildcard in the path is allowed.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class PreventionStoredInfoTypeLargeCustomDictionaryOutputPath(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param 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) -> str:
        """
        A url representing a file or path (no wildcards) in Cloud Storage. Example: `gs://[BUCKET_NAME]/dictionary.txt`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class PreventionStoredInfoTypeRegex(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupIndexes":
            suggest = "group_indexes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PreventionStoredInfoTypeRegex. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PreventionStoredInfoTypeRegex.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PreventionStoredInfoTypeRegex.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pattern: str,
                 group_indexes: Optional[Sequence[int]] = None):
        """
        :param 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 Sequence[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) -> 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")

    @property
    @pulumi.getter(name="groupIndexes")
    def group_indexes(self) -> Optional[Sequence[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")


