# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ClassificationJobS3JobDefinition',
    'ClassificationJobS3JobDefinitionBucketDefinition',
    'ClassificationJobS3JobDefinitionScoping',
    'ClassificationJobS3JobDefinitionScopingExcludes',
    'ClassificationJobS3JobDefinitionScopingExcludesAnd',
    'ClassificationJobS3JobDefinitionScopingExcludesAndSimpleScopeTerm',
    'ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTerm',
    'ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermTagValue',
    'ClassificationJobS3JobDefinitionScopingIncludes',
    'ClassificationJobS3JobDefinitionScopingIncludesAnd',
    'ClassificationJobS3JobDefinitionScopingIncludesAndSimpleScopeTerm',
    'ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTerm',
    'ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermTagValue',
    'ClassificationJobScheduleFrequency',
    'ClassificationJobUserPausedDetail',
]

@pulumi.output_type
class ClassificationJobS3JobDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketDefinitions":
            suggest = "bucket_definitions"

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

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

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

    def __init__(__self__, *,
                 bucket_definitions: Optional[Sequence['outputs.ClassificationJobS3JobDefinitionBucketDefinition']] = None,
                 scoping: Optional['outputs.ClassificationJobS3JobDefinitionScoping'] = None):
        """
        :param Sequence['ClassificationJobS3JobDefinitionBucketDefinitionArgs'] bucket_definitions: An array of objects, one for each AWS account that owns buckets to analyze. Each object specifies the account ID for an account and one or more buckets to analyze for the account. (documented below)
        :param 'ClassificationJobS3JobDefinitionScopingArgs' scoping: The property- and tag-based conditions that determine which objects to include or exclude from the analysis. (documented below)
        """
        if bucket_definitions is not None:
            pulumi.set(__self__, "bucket_definitions", bucket_definitions)
        if scoping is not None:
            pulumi.set(__self__, "scoping", scoping)

    @property
    @pulumi.getter(name="bucketDefinitions")
    def bucket_definitions(self) -> Optional[Sequence['outputs.ClassificationJobS3JobDefinitionBucketDefinition']]:
        """
        An array of objects, one for each AWS account that owns buckets to analyze. Each object specifies the account ID for an account and one or more buckets to analyze for the account. (documented below)
        """
        return pulumi.get(self, "bucket_definitions")

    @property
    @pulumi.getter
    def scoping(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScoping']:
        """
        The property- and tag-based conditions that determine which objects to include or exclude from the analysis. (documented below)
        """
        return pulumi.get(self, "scoping")


@pulumi.output_type
class ClassificationJobS3JobDefinitionBucketDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountId":
            suggest = "account_id"

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

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

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

    def __init__(__self__, *,
                 account_id: str,
                 buckets: Sequence[str]):
        """
        :param str account_id: The unique identifier for the AWS account that owns the buckets.
        :param Sequence[str] buckets: An array that lists the names of the buckets.
        """
        pulumi.set(__self__, "account_id", account_id)
        pulumi.set(__self__, "buckets", buckets)

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> str:
        """
        The unique identifier for the AWS account that owns the buckets.
        """
        return pulumi.get(self, "account_id")

    @property
    @pulumi.getter
    def buckets(self) -> Sequence[str]:
        """
        An array that lists the names of the buckets.
        """
        return pulumi.get(self, "buckets")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScoping(dict):
    def __init__(__self__, *,
                 excludes: Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludes'] = None,
                 includes: Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludes'] = None):
        """
        :param 'ClassificationJobS3JobDefinitionScopingExcludesArgs' excludes: The property- or tag-based conditions that determine which objects to exclude from the analysis. (documented below)
        :param 'ClassificationJobS3JobDefinitionScopingIncludesArgs' includes: The property- or tag-based conditions that determine which objects to include in the analysis. (documented below)
        """
        if excludes is not None:
            pulumi.set(__self__, "excludes", excludes)
        if includes is not None:
            pulumi.set(__self__, "includes", includes)

    @property
    @pulumi.getter
    def excludes(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludes']:
        """
        The property- or tag-based conditions that determine which objects to exclude from the analysis. (documented below)
        """
        return pulumi.get(self, "excludes")

    @property
    @pulumi.getter
    def includes(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludes']:
        """
        The property- or tag-based conditions that determine which objects to include in the analysis. (documented below)
        """
        return pulumi.get(self, "includes")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingExcludes(dict):
    def __init__(__self__, *,
                 ands: Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingExcludesAnd']] = None):
        """
        :param Sequence['ClassificationJobS3JobDefinitionScopingExcludesAndArgs'] ands: An array of conditions, one for each condition that determines which objects to include or exclude from the job. (documented below)
        """
        if ands is not None:
            pulumi.set(__self__, "ands", ands)

    @property
    @pulumi.getter
    def ands(self) -> Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingExcludesAnd']]:
        """
        An array of conditions, one for each condition that determines which objects to include or exclude from the job. (documented below)
        """
        return pulumi.get(self, "ands")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingExcludesAnd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "simpleScopeTerm":
            suggest = "simple_scope_term"
        elif key == "tagScopeTerm":
            suggest = "tag_scope_term"

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

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

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

    def __init__(__self__, *,
                 simple_scope_term: Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndSimpleScopeTerm'] = None,
                 tag_scope_term: Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTerm'] = None):
        """
        :param 'ClassificationJobS3JobDefinitionScopingExcludesAndSimpleScopeTermArgs' simple_scope_term: A property-based condition that defines a property, operator, and one or more values for including or excluding an object from the job.  (documented below)
        :param 'ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermArgs' tag_scope_term: A tag-based condition that defines the operator and tag keys or tag key and value pairs for including or excluding an object from the job.  (documented below)
        """
        if simple_scope_term is not None:
            pulumi.set(__self__, "simple_scope_term", simple_scope_term)
        if tag_scope_term is not None:
            pulumi.set(__self__, "tag_scope_term", tag_scope_term)

    @property
    @pulumi.getter(name="simpleScopeTerm")
    def simple_scope_term(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndSimpleScopeTerm']:
        """
        A property-based condition that defines a property, operator, and one or more values for including or excluding an object from the job.  (documented below)
        """
        return pulumi.get(self, "simple_scope_term")

    @property
    @pulumi.getter(name="tagScopeTerm")
    def tag_scope_term(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTerm']:
        """
        A tag-based condition that defines the operator and tag keys or tag key and value pairs for including or excluding an object from the job.  (documented below)
        """
        return pulumi.get(self, "tag_scope_term")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingExcludesAndSimpleScopeTerm(dict):
    def __init__(__self__, *,
                 comparator: Optional[str] = None,
                 key: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str comparator: The operator to use in a condition. Valid values are: `EQ`, `GT`, `GTE`, `LT`, `LTE`, `NE`, `CONTAINS`, `STARTS_WITH`
        :param str key: The object property to use in the condition.
        :param Sequence[str] values: An array that lists the values to use in the condition.
        """
        if comparator is not None:
            pulumi.set(__self__, "comparator", comparator)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def comparator(self) -> Optional[str]:
        """
        The operator to use in a condition. Valid values are: `EQ`, `GT`, `GTE`, `LT`, `LTE`, `NE`, `CONTAINS`, `STARTS_WITH`
        """
        return pulumi.get(self, "comparator")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The object property to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        An array that lists the values to use in the condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTerm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagValues":
            suggest = "tag_values"

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

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

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

    def __init__(__self__, *,
                 comparator: Optional[str] = None,
                 key: Optional[str] = None,
                 tag_values: Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermTagValue']] = None,
                 target: Optional[str] = None):
        """
        :param str comparator: The operator to use in the condition.
        :param str key: The tag key to use in the condition.
        :param Sequence['ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermTagValueArgs'] tag_values: The tag keys or tag key and value pairs to use in the condition.
        :param str target: The type of object to apply the condition to.
        """
        if comparator is not None:
            pulumi.set(__self__, "comparator", comparator)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if tag_values is not None:
            pulumi.set(__self__, "tag_values", tag_values)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def comparator(self) -> Optional[str]:
        """
        The operator to use in the condition.
        """
        return pulumi.get(self, "comparator")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The tag key to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="tagValues")
    def tag_values(self) -> Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermTagValue']]:
        """
        The tag keys or tag key and value pairs to use in the condition.
        """
        return pulumi.get(self, "tag_values")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        The type of object to apply the condition to.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingExcludesAndTagScopeTermTagValue(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: The object property to use in the condition.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The object property to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingIncludes(dict):
    def __init__(__self__, *,
                 ands: Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingIncludesAnd']] = None):
        """
        :param Sequence['ClassificationJobS3JobDefinitionScopingIncludesAndArgs'] ands: An array of conditions, one for each condition that determines which objects to include or exclude from the job. (documented below)
        """
        if ands is not None:
            pulumi.set(__self__, "ands", ands)

    @property
    @pulumi.getter
    def ands(self) -> Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingIncludesAnd']]:
        """
        An array of conditions, one for each condition that determines which objects to include or exclude from the job. (documented below)
        """
        return pulumi.get(self, "ands")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingIncludesAnd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "simpleScopeTerm":
            suggest = "simple_scope_term"
        elif key == "tagScopeTerm":
            suggest = "tag_scope_term"

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

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

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

    def __init__(__self__, *,
                 simple_scope_term: Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndSimpleScopeTerm'] = None,
                 tag_scope_term: Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTerm'] = None):
        """
        :param 'ClassificationJobS3JobDefinitionScopingIncludesAndSimpleScopeTermArgs' simple_scope_term: A property-based condition that defines a property, operator, and one or more values for including or excluding an object from the job.  (documented below)
        :param 'ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermArgs' tag_scope_term: A tag-based condition that defines the operator and tag keys or tag key and value pairs for including or excluding an object from the job.  (documented below)
        """
        if simple_scope_term is not None:
            pulumi.set(__self__, "simple_scope_term", simple_scope_term)
        if tag_scope_term is not None:
            pulumi.set(__self__, "tag_scope_term", tag_scope_term)

    @property
    @pulumi.getter(name="simpleScopeTerm")
    def simple_scope_term(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndSimpleScopeTerm']:
        """
        A property-based condition that defines a property, operator, and one or more values for including or excluding an object from the job.  (documented below)
        """
        return pulumi.get(self, "simple_scope_term")

    @property
    @pulumi.getter(name="tagScopeTerm")
    def tag_scope_term(self) -> Optional['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTerm']:
        """
        A tag-based condition that defines the operator and tag keys or tag key and value pairs for including or excluding an object from the job.  (documented below)
        """
        return pulumi.get(self, "tag_scope_term")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingIncludesAndSimpleScopeTerm(dict):
    def __init__(__self__, *,
                 comparator: Optional[str] = None,
                 key: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str comparator: The operator to use in a condition. Valid values are: `EQ`, `GT`, `GTE`, `LT`, `LTE`, `NE`, `CONTAINS`, `STARTS_WITH`
        :param str key: The object property to use in the condition.
        :param Sequence[str] values: An array that lists the values to use in the condition.
        """
        if comparator is not None:
            pulumi.set(__self__, "comparator", comparator)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def comparator(self) -> Optional[str]:
        """
        The operator to use in a condition. Valid values are: `EQ`, `GT`, `GTE`, `LT`, `LTE`, `NE`, `CONTAINS`, `STARTS_WITH`
        """
        return pulumi.get(self, "comparator")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The object property to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        An array that lists the values to use in the condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTerm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagValues":
            suggest = "tag_values"

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

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

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

    def __init__(__self__, *,
                 comparator: Optional[str] = None,
                 key: Optional[str] = None,
                 tag_values: Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermTagValue']] = None,
                 target: Optional[str] = None):
        """
        :param str comparator: The operator to use in the condition.
        :param str key: The tag key to use in the condition.
        :param Sequence['ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermTagValueArgs'] tag_values: The tag keys or tag key and value pairs to use in the condition.
        :param str target: The type of object to apply the condition to.
        """
        if comparator is not None:
            pulumi.set(__self__, "comparator", comparator)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if tag_values is not None:
            pulumi.set(__self__, "tag_values", tag_values)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def comparator(self) -> Optional[str]:
        """
        The operator to use in the condition.
        """
        return pulumi.get(self, "comparator")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The tag key to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="tagValues")
    def tag_values(self) -> Optional[Sequence['outputs.ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermTagValue']]:
        """
        The tag keys or tag key and value pairs to use in the condition.
        """
        return pulumi.get(self, "tag_values")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        The type of object to apply the condition to.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class ClassificationJobS3JobDefinitionScopingIncludesAndTagScopeTermTagValue(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: The object property to use in the condition.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The object property to use in the condition.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClassificationJobScheduleFrequency(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dailySchedule":
            suggest = "daily_schedule"
        elif key == "monthlySchedule":
            suggest = "monthly_schedule"
        elif key == "weeklySchedule":
            suggest = "weekly_schedule"

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

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

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

    def __init__(__self__, *,
                 daily_schedule: Optional[bool] = None,
                 monthly_schedule: Optional[int] = None,
                 weekly_schedule: Optional[str] = None):
        """
        :param bool daily_schedule: Specifies a daily recurrence pattern for running the job.
        :param int monthly_schedule: Specifies a monthly recurrence pattern for running the job.
        :param str weekly_schedule: Specifies a weekly recurrence pattern for running the job.
        """
        if daily_schedule is not None:
            pulumi.set(__self__, "daily_schedule", daily_schedule)
        if monthly_schedule is not None:
            pulumi.set(__self__, "monthly_schedule", monthly_schedule)
        if weekly_schedule is not None:
            pulumi.set(__self__, "weekly_schedule", weekly_schedule)

    @property
    @pulumi.getter(name="dailySchedule")
    def daily_schedule(self) -> Optional[bool]:
        """
        Specifies a daily recurrence pattern for running the job.
        """
        return pulumi.get(self, "daily_schedule")

    @property
    @pulumi.getter(name="monthlySchedule")
    def monthly_schedule(self) -> Optional[int]:
        """
        Specifies a monthly recurrence pattern for running the job.
        """
        return pulumi.get(self, "monthly_schedule")

    @property
    @pulumi.getter(name="weeklySchedule")
    def weekly_schedule(self) -> Optional[str]:
        """
        Specifies a weekly recurrence pattern for running the job.
        """
        return pulumi.get(self, "weekly_schedule")


@pulumi.output_type
class ClassificationJobUserPausedDetail(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "jobExpiresAt":
            suggest = "job_expires_at"
        elif key == "jobImminentExpirationHealthEventArn":
            suggest = "job_imminent_expiration_health_event_arn"
        elif key == "jobPausedAt":
            suggest = "job_paused_at"

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

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

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

    def __init__(__self__, *,
                 job_expires_at: Optional[str] = None,
                 job_imminent_expiration_health_event_arn: Optional[str] = None,
                 job_paused_at: Optional[str] = None):
        if job_expires_at is not None:
            pulumi.set(__self__, "job_expires_at", job_expires_at)
        if job_imminent_expiration_health_event_arn is not None:
            pulumi.set(__self__, "job_imminent_expiration_health_event_arn", job_imminent_expiration_health_event_arn)
        if job_paused_at is not None:
            pulumi.set(__self__, "job_paused_at", job_paused_at)

    @property
    @pulumi.getter(name="jobExpiresAt")
    def job_expires_at(self) -> Optional[str]:
        return pulumi.get(self, "job_expires_at")

    @property
    @pulumi.getter(name="jobImminentExpirationHealthEventArn")
    def job_imminent_expiration_health_event_arn(self) -> Optional[str]:
        return pulumi.get(self, "job_imminent_expiration_health_event_arn")

    @property
    @pulumi.getter(name="jobPausedAt")
    def job_paused_at(self) -> Optional[str]:
        return pulumi.get(self, "job_paused_at")


