# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** 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 ._enums import *

__all__ = [
    'AccessPointPublicAccessBlockConfigurationArgs',
    'AccessPointVpcConfigurationArgs',
    'BucketAbortIncompleteMultipartUploadArgs',
    'BucketAccelerateConfigurationArgs',
    'BucketAccessControlTranslationArgs',
    'BucketAnalyticsConfigurationArgs',
    'BucketBucketEncryptionArgs',
    'BucketCorsConfigurationArgs',
    'BucketCorsRuleArgs',
    'BucketDataExportArgs',
    'BucketDefaultRetentionArgs',
    'BucketDeleteMarkerReplicationArgs',
    'BucketDestinationArgs',
    'BucketEncryptionConfigurationArgs',
    'BucketFilterRuleArgs',
    'BucketIntelligentTieringConfigurationArgs',
    'BucketInventoryConfigurationArgs',
    'BucketLambdaConfigurationArgs',
    'BucketLifecycleConfigurationArgs',
    'BucketLoggingConfigurationArgs',
    'BucketMetricsConfigurationArgs',
    'BucketMetricsArgs',
    'BucketNoncurrentVersionTransitionArgs',
    'BucketNotificationConfigurationArgs',
    'BucketNotificationFilterArgs',
    'BucketObjectLockConfigurationArgs',
    'BucketObjectLockRuleArgs',
    'BucketOwnershipControlsRuleArgs',
    'BucketOwnershipControlsArgs',
    'BucketPublicAccessBlockConfigurationArgs',
    'BucketQueueConfigurationArgs',
    'BucketRedirectAllRequestsToArgs',
    'BucketRedirectRuleArgs',
    'BucketReplicaModificationsArgs',
    'BucketReplicationConfigurationArgs',
    'BucketReplicationDestinationArgs',
    'BucketReplicationRuleAndOperatorArgs',
    'BucketReplicationRuleFilterArgs',
    'BucketReplicationRuleArgs',
    'BucketReplicationTimeValueArgs',
    'BucketReplicationTimeArgs',
    'BucketRoutingRuleConditionArgs',
    'BucketRoutingRuleArgs',
    'BucketRuleArgs',
    'BucketS3KeyFilterArgs',
    'BucketServerSideEncryptionByDefaultArgs',
    'BucketServerSideEncryptionRuleArgs',
    'BucketSourceSelectionCriteriaArgs',
    'BucketSseKmsEncryptedObjectsArgs',
    'BucketStorageClassAnalysisArgs',
    'BucketTagFilterArgs',
    'BucketTagArgs',
    'BucketTieringArgs',
    'BucketTopicConfigurationArgs',
    'BucketTransitionArgs',
    'BucketVersioningConfigurationArgs',
    'BucketWebsiteConfigurationArgs',
    'MultiRegionAccessPointPublicAccessBlockConfigurationArgs',
    'MultiRegionAccessPointRegionArgs',
    'StorageLensAccountLevelArgs',
    'StorageLensActivityMetricsArgs',
    'StorageLensAwsOrgArgs',
    'StorageLensBucketLevelArgs',
    'StorageLensBucketsAndRegionsArgs',
    'StorageLensDataExportArgs',
    'StorageLensEncryptionArgs',
    'StorageLensPrefixLevelStorageMetricsArgs',
    'StorageLensPrefixLevelArgs',
    'StorageLensS3BucketDestinationArgs',
    'StorageLensSelectionCriteriaArgs',
    'StorageLensStorageLensConfigurationArgs',
    'StorageLensTagArgs',
]

@pulumi.input_type
class AccessPointPublicAccessBlockConfigurationArgs:
    def __init__(__self__, *,
                 block_public_acls: Optional[pulumi.Input[bool]] = None,
                 block_public_policy: Optional[pulumi.Input[bool]] = None,
                 ignore_public_acls: Optional[pulumi.Input[bool]] = None,
                 restrict_public_buckets: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] block_public_acls: Specifies whether Amazon S3 should block public access control lists (ACLs) for buckets in this account. Setting this element to TRUE causes the following behavior:
               - PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.
                - PUT Object calls fail if the request includes a public ACL.
               . - PUT Bucket calls fail if the request includes a public ACL.
               Enabling this setting doesn't affect existing policies or ACLs.
        :param pulumi.Input[bool] block_public_policy: Specifies whether Amazon S3 should block public bucket policies for buckets in this account. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access. Enabling this setting doesn't affect existing bucket policies.
        :param pulumi.Input[bool] ignore_public_acls: Specifies whether Amazon S3 should ignore public ACLs for buckets in this account. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on buckets in this account and any objects that they contain. Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
        :param pulumi.Input[bool] restrict_public_buckets: Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS services and authorized users within this account if the bucket has a public policy.
               Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
        """
        if block_public_acls is not None:
            pulumi.set(__self__, "block_public_acls", block_public_acls)
        if block_public_policy is not None:
            pulumi.set(__self__, "block_public_policy", block_public_policy)
        if ignore_public_acls is not None:
            pulumi.set(__self__, "ignore_public_acls", ignore_public_acls)
        if restrict_public_buckets is not None:
            pulumi.set(__self__, "restrict_public_buckets", restrict_public_buckets)

    @property
    @pulumi.getter(name="blockPublicAcls")
    def block_public_acls(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should block public access control lists (ACLs) for buckets in this account. Setting this element to TRUE causes the following behavior:
        - PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.
         - PUT Object calls fail if the request includes a public ACL.
        . - PUT Bucket calls fail if the request includes a public ACL.
        Enabling this setting doesn't affect existing policies or ACLs.
        """
        return pulumi.get(self, "block_public_acls")

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

    @property
    @pulumi.getter(name="blockPublicPolicy")
    def block_public_policy(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should block public bucket policies for buckets in this account. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access. Enabling this setting doesn't affect existing bucket policies.
        """
        return pulumi.get(self, "block_public_policy")

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

    @property
    @pulumi.getter(name="ignorePublicAcls")
    def ignore_public_acls(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should ignore public ACLs for buckets in this account. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on buckets in this account and any objects that they contain. Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
        """
        return pulumi.get(self, "ignore_public_acls")

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

    @property
    @pulumi.getter(name="restrictPublicBuckets")
    def restrict_public_buckets(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS services and authorized users within this account if the bucket has a public policy.
        Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
        """
        return pulumi.get(self, "restrict_public_buckets")

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


@pulumi.input_type
class AccessPointVpcConfigurationArgs:
    def __init__(__self__, *,
                 vpc_id: Optional[pulumi.Input[str]] = None):
        """
        The Virtual Private Cloud (VPC) configuration for a bucket access point.
        :param pulumi.Input[str] vpc_id: If this field is specified, this access point will only allow connections from the specified VPC ID.
        """
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[pulumi.Input[str]]:
        """
        If this field is specified, this access point will only allow connections from the specified VPC ID.
        """
        return pulumi.get(self, "vpc_id")

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


@pulumi.input_type
class BucketAbortIncompleteMultipartUploadArgs:
    def __init__(__self__, *,
                 days_after_initiation: pulumi.Input[int]):
        pulumi.set(__self__, "days_after_initiation", days_after_initiation)

    @property
    @pulumi.getter(name="daysAfterInitiation")
    def days_after_initiation(self) -> pulumi.Input[int]:
        return pulumi.get(self, "days_after_initiation")

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


@pulumi.input_type
class BucketAccelerateConfigurationArgs:
    def __init__(__self__, *,
                 acceleration_status: pulumi.Input[str]):
        pulumi.set(__self__, "acceleration_status", acceleration_status)

    @property
    @pulumi.getter(name="accelerationStatus")
    def acceleration_status(self) -> pulumi.Input[str]:
        return pulumi.get(self, "acceleration_status")

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


@pulumi.input_type
class BucketAccessControlTranslationArgs:
    def __init__(__self__, *,
                 owner: pulumi.Input[str]):
        pulumi.set(__self__, "owner", owner)

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

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


@pulumi.input_type
class BucketAnalyticsConfigurationArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 storage_class_analysis: pulumi.Input['BucketStorageClassAnalysisArgs'],
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]] = None):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "storage_class_analysis", storage_class_analysis)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)

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

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

    @property
    @pulumi.getter(name="storageClassAnalysis")
    def storage_class_analysis(self) -> pulumi.Input['BucketStorageClassAnalysisArgs']:
        return pulumi.get(self, "storage_class_analysis")

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

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

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

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

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


@pulumi.input_type
class BucketBucketEncryptionArgs:
    def __init__(__self__, *,
                 server_side_encryption_configuration: pulumi.Input[Sequence[pulumi.Input['BucketServerSideEncryptionRuleArgs']]]):
        pulumi.set(__self__, "server_side_encryption_configuration", server_side_encryption_configuration)

    @property
    @pulumi.getter(name="serverSideEncryptionConfiguration")
    def server_side_encryption_configuration(self) -> pulumi.Input[Sequence[pulumi.Input['BucketServerSideEncryptionRuleArgs']]]:
        return pulumi.get(self, "server_side_encryption_configuration")

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


@pulumi.input_type
class BucketCorsConfigurationArgs:
    def __init__(__self__, *,
                 cors_rules: pulumi.Input[Sequence[pulumi.Input['BucketCorsRuleArgs']]]):
        pulumi.set(__self__, "cors_rules", cors_rules)

    @property
    @pulumi.getter(name="corsRules")
    def cors_rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketCorsRuleArgs']]]:
        return pulumi.get(self, "cors_rules")

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


@pulumi.input_type
class BucketCorsRuleArgs:
    def __init__(__self__, *,
                 allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 exposed_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 max_age: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "allowed_methods", allowed_methods)
        pulumi.set(__self__, "allowed_origins", allowed_origins)
        if allowed_headers is not None:
            pulumi.set(__self__, "allowed_headers", allowed_headers)
        if exposed_headers is not None:
            pulumi.set(__self__, "exposed_headers", exposed_headers)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "allowed_methods")

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

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "allowed_origins")

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

    @property
    @pulumi.getter(name="allowedHeaders")
    def allowed_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "allowed_headers")

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

    @property
    @pulumi.getter(name="exposedHeaders")
    def exposed_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exposed_headers")

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

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

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

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_age")

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


@pulumi.input_type
class BucketDataExportArgs:
    def __init__(__self__, *,
                 destination: pulumi.Input['BucketDestinationArgs'],
                 output_schema_version: pulumi.Input[str]):
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "output_schema_version", output_schema_version)

    @property
    @pulumi.getter
    def destination(self) -> pulumi.Input['BucketDestinationArgs']:
        return pulumi.get(self, "destination")

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

    @property
    @pulumi.getter(name="outputSchemaVersion")
    def output_schema_version(self) -> pulumi.Input[str]:
        return pulumi.get(self, "output_schema_version")

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


@pulumi.input_type
class BucketDefaultRetentionArgs:
    def __init__(__self__, *,
                 days: Optional[pulumi.Input[int]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 years: Optional[pulumi.Input[int]] = None):
        if days is not None:
            pulumi.set(__self__, "days", days)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if years is not None:
            pulumi.set(__self__, "years", years)

    @property
    @pulumi.getter
    def days(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "days")

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

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

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

    @property
    @pulumi.getter
    def years(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "years")

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


@pulumi.input_type
class BucketDeleteMarkerReplicationArgs:
    def __init__(__self__, *,
                 status: Optional[pulumi.Input[str]] = None):
        if status is not None:
            pulumi.set(__self__, "status", status)

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

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


@pulumi.input_type
class BucketDestinationArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 format: pulumi.Input[str],
                 bucket_account_id: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "format", format)
        if bucket_account_id is not None:
            pulumi.set(__self__, "bucket_account_id", bucket_account_id)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter(name="bucketArn")
    def bucket_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_arn")

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

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

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

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

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

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

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


@pulumi.input_type
class BucketEncryptionConfigurationArgs:
    def __init__(__self__, *,
                 replica_kms_key_id: pulumi.Input[str]):
        pulumi.set(__self__, "replica_kms_key_id", replica_kms_key_id)

    @property
    @pulumi.getter(name="replicaKmsKeyID")
    def replica_kms_key_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "replica_kms_key_id")

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


@pulumi.input_type
class BucketFilterRuleArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class BucketIntelligentTieringConfigurationArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 status: pulumi.Input[str],
                 tierings: pulumi.Input[Sequence[pulumi.Input['BucketTieringArgs']]],
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]] = None):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tierings", tierings)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)

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

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

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

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

    @property
    @pulumi.getter
    def tierings(self) -> pulumi.Input[Sequence[pulumi.Input['BucketTieringArgs']]]:
        return pulumi.get(self, "tierings")

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

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

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

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

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


@pulumi.input_type
class BucketInventoryConfigurationArgs:
    def __init__(__self__, *,
                 destination: pulumi.Input['BucketDestinationArgs'],
                 enabled: pulumi.Input[bool],
                 id: pulumi.Input[str],
                 included_object_versions: pulumi.Input[str],
                 schedule_frequency: pulumi.Input[str],
                 optional_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "included_object_versions", included_object_versions)
        pulumi.set(__self__, "schedule_frequency", schedule_frequency)
        if optional_fields is not None:
            pulumi.set(__self__, "optional_fields", optional_fields)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def destination(self) -> pulumi.Input['BucketDestinationArgs']:
        return pulumi.get(self, "destination")

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

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        return pulumi.get(self, "enabled")

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

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

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

    @property
    @pulumi.getter(name="includedObjectVersions")
    def included_object_versions(self) -> pulumi.Input[str]:
        return pulumi.get(self, "included_object_versions")

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

    @property
    @pulumi.getter(name="scheduleFrequency")
    def schedule_frequency(self) -> pulumi.Input[str]:
        return pulumi.get(self, "schedule_frequency")

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

    @property
    @pulumi.getter(name="optionalFields")
    def optional_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "optional_fields")

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

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

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


@pulumi.input_type
class BucketLambdaConfigurationArgs:
    def __init__(__self__, *,
                 event: pulumi.Input[str],
                 function: pulumi.Input[str],
                 filter: Optional[pulumi.Input['BucketNotificationFilterArgs']] = None):
        pulumi.set(__self__, "event", event)
        pulumi.set(__self__, "function", function)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)

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

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

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

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

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['BucketNotificationFilterArgs']]:
        return pulumi.get(self, "filter")

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


@pulumi.input_type
class BucketLifecycleConfigurationArgs:
    def __init__(__self__, *,
                 rules: pulumi.Input[Sequence[pulumi.Input['BucketRuleArgs']]]):
        pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketRuleArgs']]]:
        return pulumi.get(self, "rules")

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


@pulumi.input_type
class BucketLoggingConfigurationArgs:
    def __init__(__self__, *,
                 destination_bucket_name: Optional[pulumi.Input[str]] = None,
                 log_file_prefix: Optional[pulumi.Input[str]] = None):
        if destination_bucket_name is not None:
            pulumi.set(__self__, "destination_bucket_name", destination_bucket_name)
        if log_file_prefix is not None:
            pulumi.set(__self__, "log_file_prefix", log_file_prefix)

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

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

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

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


@pulumi.input_type
class BucketMetricsConfigurationArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 access_point_arn: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]] = None):
        pulumi.set(__self__, "id", id)
        if access_point_arn is not None:
            pulumi.set(__self__, "access_point_arn", access_point_arn)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

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


@pulumi.input_type
class BucketMetricsArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str],
                 event_threshold: Optional[pulumi.Input['BucketReplicationTimeValueArgs']] = None):
        pulumi.set(__self__, "status", status)
        if event_threshold is not None:
            pulumi.set(__self__, "event_threshold", event_threshold)

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

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

    @property
    @pulumi.getter(name="eventThreshold")
    def event_threshold(self) -> Optional[pulumi.Input['BucketReplicationTimeValueArgs']]:
        return pulumi.get(self, "event_threshold")

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


@pulumi.input_type
class BucketNoncurrentVersionTransitionArgs:
    def __init__(__self__, *,
                 storage_class: pulumi.Input[str],
                 transition_in_days: pulumi.Input[int]):
        pulumi.set(__self__, "storage_class", storage_class)
        pulumi.set(__self__, "transition_in_days", transition_in_days)

    @property
    @pulumi.getter(name="storageClass")
    def storage_class(self) -> pulumi.Input[str]:
        return pulumi.get(self, "storage_class")

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

    @property
    @pulumi.getter(name="transitionInDays")
    def transition_in_days(self) -> pulumi.Input[int]:
        return pulumi.get(self, "transition_in_days")

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


@pulumi.input_type
class BucketNotificationConfigurationArgs:
    def __init__(__self__, *,
                 lambda_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['BucketLambdaConfigurationArgs']]]] = None,
                 queue_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['BucketQueueConfigurationArgs']]]] = None,
                 topic_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTopicConfigurationArgs']]]] = None):
        if lambda_configurations is not None:
            pulumi.set(__self__, "lambda_configurations", lambda_configurations)
        if queue_configurations is not None:
            pulumi.set(__self__, "queue_configurations", queue_configurations)
        if topic_configurations is not None:
            pulumi.set(__self__, "topic_configurations", topic_configurations)

    @property
    @pulumi.getter(name="lambdaConfigurations")
    def lambda_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketLambdaConfigurationArgs']]]]:
        return pulumi.get(self, "lambda_configurations")

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

    @property
    @pulumi.getter(name="queueConfigurations")
    def queue_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketQueueConfigurationArgs']]]]:
        return pulumi.get(self, "queue_configurations")

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

    @property
    @pulumi.getter(name="topicConfigurations")
    def topic_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTopicConfigurationArgs']]]]:
        return pulumi.get(self, "topic_configurations")

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


@pulumi.input_type
class BucketNotificationFilterArgs:
    def __init__(__self__, *,
                 s3_key: pulumi.Input['BucketS3KeyFilterArgs']):
        pulumi.set(__self__, "s3_key", s3_key)

    @property
    @pulumi.getter(name="s3Key")
    def s3_key(self) -> pulumi.Input['BucketS3KeyFilterArgs']:
        return pulumi.get(self, "s3_key")

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


@pulumi.input_type
class BucketObjectLockConfigurationArgs:
    def __init__(__self__, *,
                 object_lock_enabled: Optional[pulumi.Input[str]] = None,
                 rule: Optional[pulumi.Input['BucketObjectLockRuleArgs']] = None):
        if object_lock_enabled is not None:
            pulumi.set(__self__, "object_lock_enabled", object_lock_enabled)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

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

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

    @property
    @pulumi.getter
    def rule(self) -> Optional[pulumi.Input['BucketObjectLockRuleArgs']]:
        return pulumi.get(self, "rule")

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


@pulumi.input_type
class BucketObjectLockRuleArgs:
    def __init__(__self__, *,
                 default_retention: Optional[pulumi.Input['BucketDefaultRetentionArgs']] = None):
        if default_retention is not None:
            pulumi.set(__self__, "default_retention", default_retention)

    @property
    @pulumi.getter(name="defaultRetention")
    def default_retention(self) -> Optional[pulumi.Input['BucketDefaultRetentionArgs']]:
        return pulumi.get(self, "default_retention")

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


@pulumi.input_type
class BucketOwnershipControlsRuleArgs:
    def __init__(__self__, *,
                 object_ownership: Optional[pulumi.Input[str]] = None):
        if object_ownership is not None:
            pulumi.set(__self__, "object_ownership", object_ownership)

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

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


@pulumi.input_type
class BucketOwnershipControlsArgs:
    def __init__(__self__, *,
                 rules: pulumi.Input[Sequence[pulumi.Input['BucketOwnershipControlsRuleArgs']]]):
        pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketOwnershipControlsRuleArgs']]]:
        return pulumi.get(self, "rules")

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


@pulumi.input_type
class BucketPublicAccessBlockConfigurationArgs:
    def __init__(__self__, *,
                 block_public_acls: Optional[pulumi.Input[bool]] = None,
                 block_public_policy: Optional[pulumi.Input[bool]] = None,
                 ignore_public_acls: Optional[pulumi.Input[bool]] = None,
                 restrict_public_buckets: Optional[pulumi.Input[bool]] = None):
        if block_public_acls is not None:
            pulumi.set(__self__, "block_public_acls", block_public_acls)
        if block_public_policy is not None:
            pulumi.set(__self__, "block_public_policy", block_public_policy)
        if ignore_public_acls is not None:
            pulumi.set(__self__, "ignore_public_acls", ignore_public_acls)
        if restrict_public_buckets is not None:
            pulumi.set(__self__, "restrict_public_buckets", restrict_public_buckets)

    @property
    @pulumi.getter(name="blockPublicAcls")
    def block_public_acls(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "block_public_acls")

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

    @property
    @pulumi.getter(name="blockPublicPolicy")
    def block_public_policy(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "block_public_policy")

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

    @property
    @pulumi.getter(name="ignorePublicAcls")
    def ignore_public_acls(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ignore_public_acls")

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

    @property
    @pulumi.getter(name="restrictPublicBuckets")
    def restrict_public_buckets(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "restrict_public_buckets")

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


@pulumi.input_type
class BucketQueueConfigurationArgs:
    def __init__(__self__, *,
                 event: pulumi.Input[str],
                 queue: pulumi.Input[str],
                 filter: Optional[pulumi.Input['BucketNotificationFilterArgs']] = None):
        pulumi.set(__self__, "event", event)
        pulumi.set(__self__, "queue", queue)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)

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

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

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

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

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['BucketNotificationFilterArgs']]:
        return pulumi.get(self, "filter")

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


@pulumi.input_type
class BucketRedirectAllRequestsToArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 protocol: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "host_name", host_name)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "host_name")

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

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

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


@pulumi.input_type
class BucketRedirectRuleArgs:
    def __init__(__self__, *,
                 host_name: Optional[pulumi.Input[str]] = None,
                 http_redirect_code: Optional[pulumi.Input[str]] = None,
                 protocol: Optional[pulumi.Input[str]] = None,
                 replace_key_prefix_with: Optional[pulumi.Input[str]] = None,
                 replace_key_with: Optional[pulumi.Input[str]] = None):
        if host_name is not None:
            pulumi.set(__self__, "host_name", host_name)
        if http_redirect_code is not None:
            pulumi.set(__self__, "http_redirect_code", http_redirect_code)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if replace_key_prefix_with is not None:
            pulumi.set(__self__, "replace_key_prefix_with", replace_key_prefix_with)
        if replace_key_with is not None:
            pulumi.set(__self__, "replace_key_with", replace_key_with)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class BucketReplicaModificationsArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str]):
        pulumi.set(__self__, "status", status)

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

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


@pulumi.input_type
class BucketReplicationConfigurationArgs:
    def __init__(__self__, *,
                 role: pulumi.Input[str],
                 rules: pulumi.Input[Sequence[pulumi.Input['BucketReplicationRuleArgs']]]):
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "rules", rules)

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

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

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketReplicationRuleArgs']]]:
        return pulumi.get(self, "rules")

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


@pulumi.input_type
class BucketReplicationDestinationArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 access_control_translation: Optional[pulumi.Input['BucketAccessControlTranslationArgs']] = None,
                 account: Optional[pulumi.Input[str]] = None,
                 encryption_configuration: Optional[pulumi.Input['BucketEncryptionConfigurationArgs']] = None,
                 metrics: Optional[pulumi.Input['BucketMetricsArgs']] = None,
                 replication_time: Optional[pulumi.Input['BucketReplicationTimeArgs']] = None,
                 storage_class: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket", bucket)
        if access_control_translation is not None:
            pulumi.set(__self__, "access_control_translation", access_control_translation)
        if account is not None:
            pulumi.set(__self__, "account", account)
        if encryption_configuration is not None:
            pulumi.set(__self__, "encryption_configuration", encryption_configuration)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)
        if replication_time is not None:
            pulumi.set(__self__, "replication_time", replication_time)
        if storage_class is not None:
            pulumi.set(__self__, "storage_class", storage_class)

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

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

    @property
    @pulumi.getter(name="accessControlTranslation")
    def access_control_translation(self) -> Optional[pulumi.Input['BucketAccessControlTranslationArgs']]:
        return pulumi.get(self, "access_control_translation")

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

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

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

    @property
    @pulumi.getter(name="encryptionConfiguration")
    def encryption_configuration(self) -> Optional[pulumi.Input['BucketEncryptionConfigurationArgs']]:
        return pulumi.get(self, "encryption_configuration")

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

    @property
    @pulumi.getter
    def metrics(self) -> Optional[pulumi.Input['BucketMetricsArgs']]:
        return pulumi.get(self, "metrics")

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

    @property
    @pulumi.getter(name="replicationTime")
    def replication_time(self) -> Optional[pulumi.Input['BucketReplicationTimeArgs']]:
        return pulumi.get(self, "replication_time")

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

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

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


@pulumi.input_type
class BucketReplicationRuleAndOperatorArgs:
    def __init__(__self__, *,
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]] = None):
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)

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

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

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

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


@pulumi.input_type
class BucketReplicationRuleFilterArgs:
    def __init__(__self__, *,
                 and_: Optional[pulumi.Input['BucketReplicationRuleAndOperatorArgs']] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filter: Optional[pulumi.Input['BucketTagFilterArgs']] = None):
        if and_ is not None:
            pulumi.set(__self__, "and_", and_)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filter is not None:
            pulumi.set(__self__, "tag_filter", tag_filter)

    @property
    @pulumi.getter(name="and")
    def and_(self) -> Optional[pulumi.Input['BucketReplicationRuleAndOperatorArgs']]:
        return pulumi.get(self, "and_")

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

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

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

    @property
    @pulumi.getter(name="tagFilter")
    def tag_filter(self) -> Optional[pulumi.Input['BucketTagFilterArgs']]:
        return pulumi.get(self, "tag_filter")

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


@pulumi.input_type
class BucketReplicationRuleArgs:
    def __init__(__self__, *,
                 destination: pulumi.Input['BucketReplicationDestinationArgs'],
                 status: pulumi.Input[str],
                 delete_marker_replication: Optional[pulumi.Input['BucketDeleteMarkerReplicationArgs']] = None,
                 filter: Optional[pulumi.Input['BucketReplicationRuleFilterArgs']] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 priority: Optional[pulumi.Input[int]] = None,
                 source_selection_criteria: Optional[pulumi.Input['BucketSourceSelectionCriteriaArgs']] = None):
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "status", status)
        if delete_marker_replication is not None:
            pulumi.set(__self__, "delete_marker_replication", delete_marker_replication)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if source_selection_criteria is not None:
            pulumi.set(__self__, "source_selection_criteria", source_selection_criteria)

    @property
    @pulumi.getter
    def destination(self) -> pulumi.Input['BucketReplicationDestinationArgs']:
        return pulumi.get(self, "destination")

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

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

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

    @property
    @pulumi.getter(name="deleteMarkerReplication")
    def delete_marker_replication(self) -> Optional[pulumi.Input['BucketDeleteMarkerReplicationArgs']]:
        return pulumi.get(self, "delete_marker_replication")

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

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['BucketReplicationRuleFilterArgs']]:
        return pulumi.get(self, "filter")

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

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

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

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

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

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter(name="sourceSelectionCriteria")
    def source_selection_criteria(self) -> Optional[pulumi.Input['BucketSourceSelectionCriteriaArgs']]:
        return pulumi.get(self, "source_selection_criteria")

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


@pulumi.input_type
class BucketReplicationTimeValueArgs:
    def __init__(__self__, *,
                 minutes: pulumi.Input[int]):
        pulumi.set(__self__, "minutes", minutes)

    @property
    @pulumi.getter
    def minutes(self) -> pulumi.Input[int]:
        return pulumi.get(self, "minutes")

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


@pulumi.input_type
class BucketReplicationTimeArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str],
                 time: pulumi.Input['BucketReplicationTimeValueArgs']):
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "time", time)

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

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

    @property
    @pulumi.getter
    def time(self) -> pulumi.Input['BucketReplicationTimeValueArgs']:
        return pulumi.get(self, "time")

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


@pulumi.input_type
class BucketRoutingRuleConditionArgs:
    def __init__(__self__, *,
                 http_error_code_returned_equals: Optional[pulumi.Input[str]] = None,
                 key_prefix_equals: Optional[pulumi.Input[str]] = None):
        if http_error_code_returned_equals is not None:
            pulumi.set(__self__, "http_error_code_returned_equals", http_error_code_returned_equals)
        if key_prefix_equals is not None:
            pulumi.set(__self__, "key_prefix_equals", key_prefix_equals)

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

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

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

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


@pulumi.input_type
class BucketRoutingRuleArgs:
    def __init__(__self__, *,
                 redirect_rule: pulumi.Input['BucketRedirectRuleArgs'],
                 routing_rule_condition: Optional[pulumi.Input['BucketRoutingRuleConditionArgs']] = None):
        pulumi.set(__self__, "redirect_rule", redirect_rule)
        if routing_rule_condition is not None:
            pulumi.set(__self__, "routing_rule_condition", routing_rule_condition)

    @property
    @pulumi.getter(name="redirectRule")
    def redirect_rule(self) -> pulumi.Input['BucketRedirectRuleArgs']:
        return pulumi.get(self, "redirect_rule")

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

    @property
    @pulumi.getter(name="routingRuleCondition")
    def routing_rule_condition(self) -> Optional[pulumi.Input['BucketRoutingRuleConditionArgs']]:
        return pulumi.get(self, "routing_rule_condition")

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


@pulumi.input_type
class BucketRuleArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str],
                 abort_incomplete_multipart_upload: Optional[pulumi.Input['BucketAbortIncompleteMultipartUploadArgs']] = None,
                 expiration_date: Optional[pulumi.Input[str]] = None,
                 expiration_in_days: Optional[pulumi.Input[int]] = None,
                 expired_object_delete_marker: Optional[pulumi.Input[bool]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 noncurrent_version_expiration_in_days: Optional[pulumi.Input[int]] = None,
                 noncurrent_version_transition: Optional[pulumi.Input['BucketNoncurrentVersionTransitionArgs']] = None,
                 noncurrent_version_transitions: Optional[pulumi.Input[Sequence[pulumi.Input['BucketNoncurrentVersionTransitionArgs']]]] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]] = None,
                 transition: Optional[pulumi.Input['BucketTransitionArgs']] = None,
                 transitions: Optional[pulumi.Input[Sequence[pulumi.Input['BucketTransitionArgs']]]] = None):
        pulumi.set(__self__, "status", status)
        if abort_incomplete_multipart_upload is not None:
            pulumi.set(__self__, "abort_incomplete_multipart_upload", abort_incomplete_multipart_upload)
        if expiration_date is not None:
            pulumi.set(__self__, "expiration_date", expiration_date)
        if expiration_in_days is not None:
            pulumi.set(__self__, "expiration_in_days", expiration_in_days)
        if expired_object_delete_marker is not None:
            pulumi.set(__self__, "expired_object_delete_marker", expired_object_delete_marker)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if noncurrent_version_expiration_in_days is not None:
            pulumi.set(__self__, "noncurrent_version_expiration_in_days", noncurrent_version_expiration_in_days)
        if noncurrent_version_transition is not None:
            pulumi.set(__self__, "noncurrent_version_transition", noncurrent_version_transition)
        if noncurrent_version_transitions is not None:
            pulumi.set(__self__, "noncurrent_version_transitions", noncurrent_version_transitions)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if tag_filters is not None:
            pulumi.set(__self__, "tag_filters", tag_filters)
        if transition is not None:
            pulumi.set(__self__, "transition", transition)
        if transitions is not None:
            pulumi.set(__self__, "transitions", transitions)

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

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

    @property
    @pulumi.getter(name="abortIncompleteMultipartUpload")
    def abort_incomplete_multipart_upload(self) -> Optional[pulumi.Input['BucketAbortIncompleteMultipartUploadArgs']]:
        return pulumi.get(self, "abort_incomplete_multipart_upload")

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

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

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

    @property
    @pulumi.getter(name="expirationInDays")
    def expiration_in_days(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "expiration_in_days")

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

    @property
    @pulumi.getter(name="expiredObjectDeleteMarker")
    def expired_object_delete_marker(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "expired_object_delete_marker")

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

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

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

    @property
    @pulumi.getter(name="noncurrentVersionExpirationInDays")
    def noncurrent_version_expiration_in_days(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "noncurrent_version_expiration_in_days")

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

    @property
    @pulumi.getter(name="noncurrentVersionTransition")
    def noncurrent_version_transition(self) -> Optional[pulumi.Input['BucketNoncurrentVersionTransitionArgs']]:
        return pulumi.get(self, "noncurrent_version_transition")

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

    @property
    @pulumi.getter(name="noncurrentVersionTransitions")
    def noncurrent_version_transitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketNoncurrentVersionTransitionArgs']]]]:
        return pulumi.get(self, "noncurrent_version_transitions")

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

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

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

    @property
    @pulumi.getter(name="tagFilters")
    def tag_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTagFilterArgs']]]]:
        return pulumi.get(self, "tag_filters")

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

    @property
    @pulumi.getter
    def transition(self) -> Optional[pulumi.Input['BucketTransitionArgs']]:
        return pulumi.get(self, "transition")

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

    @property
    @pulumi.getter
    def transitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketTransitionArgs']]]]:
        return pulumi.get(self, "transitions")

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


@pulumi.input_type
class BucketS3KeyFilterArgs:
    def __init__(__self__, *,
                 rules: pulumi.Input[Sequence[pulumi.Input['BucketFilterRuleArgs']]]):
        pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['BucketFilterRuleArgs']]]:
        return pulumi.get(self, "rules")

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


@pulumi.input_type
class BucketServerSideEncryptionByDefaultArgs:
    def __init__(__self__, *,
                 s_se_algorithm: pulumi.Input[str],
                 k_ms_master_key_id: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "s_se_algorithm", s_se_algorithm)
        if k_ms_master_key_id is not None:
            pulumi.set(__self__, "k_ms_master_key_id", k_ms_master_key_id)

    @property
    @pulumi.getter(name="sSEAlgorithm")
    def s_se_algorithm(self) -> pulumi.Input[str]:
        return pulumi.get(self, "s_se_algorithm")

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

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

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


@pulumi.input_type
class BucketServerSideEncryptionRuleArgs:
    def __init__(__self__, *,
                 bucket_key_enabled: Optional[pulumi.Input[bool]] = None,
                 server_side_encryption_by_default: Optional[pulumi.Input['BucketServerSideEncryptionByDefaultArgs']] = None):
        if bucket_key_enabled is not None:
            pulumi.set(__self__, "bucket_key_enabled", bucket_key_enabled)
        if server_side_encryption_by_default is not None:
            pulumi.set(__self__, "server_side_encryption_by_default", server_side_encryption_by_default)

    @property
    @pulumi.getter(name="bucketKeyEnabled")
    def bucket_key_enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "bucket_key_enabled")

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

    @property
    @pulumi.getter(name="serverSideEncryptionByDefault")
    def server_side_encryption_by_default(self) -> Optional[pulumi.Input['BucketServerSideEncryptionByDefaultArgs']]:
        return pulumi.get(self, "server_side_encryption_by_default")

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


@pulumi.input_type
class BucketSourceSelectionCriteriaArgs:
    def __init__(__self__, *,
                 replica_modifications: Optional[pulumi.Input['BucketReplicaModificationsArgs']] = None,
                 sse_kms_encrypted_objects: Optional[pulumi.Input['BucketSseKmsEncryptedObjectsArgs']] = None):
        if replica_modifications is not None:
            pulumi.set(__self__, "replica_modifications", replica_modifications)
        if sse_kms_encrypted_objects is not None:
            pulumi.set(__self__, "sse_kms_encrypted_objects", sse_kms_encrypted_objects)

    @property
    @pulumi.getter(name="replicaModifications")
    def replica_modifications(self) -> Optional[pulumi.Input['BucketReplicaModificationsArgs']]:
        return pulumi.get(self, "replica_modifications")

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

    @property
    @pulumi.getter(name="sseKmsEncryptedObjects")
    def sse_kms_encrypted_objects(self) -> Optional[pulumi.Input['BucketSseKmsEncryptedObjectsArgs']]:
        return pulumi.get(self, "sse_kms_encrypted_objects")

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


@pulumi.input_type
class BucketSseKmsEncryptedObjectsArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str]):
        pulumi.set(__self__, "status", status)

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

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


@pulumi.input_type
class BucketStorageClassAnalysisArgs:
    def __init__(__self__, *,
                 data_export: Optional[pulumi.Input['BucketDataExportArgs']] = None):
        if data_export is not None:
            pulumi.set(__self__, "data_export", data_export)

    @property
    @pulumi.getter(name="dataExport")
    def data_export(self) -> Optional[pulumi.Input['BucketDataExportArgs']]:
        return pulumi.get(self, "data_export")

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


@pulumi.input_type
class BucketTagFilterArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class BucketTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class BucketTieringArgs:
    def __init__(__self__, *,
                 access_tier: pulumi.Input[str],
                 days: pulumi.Input[int]):
        pulumi.set(__self__, "access_tier", access_tier)
        pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter(name="accessTier")
    def access_tier(self) -> pulumi.Input[str]:
        return pulumi.get(self, "access_tier")

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

    @property
    @pulumi.getter
    def days(self) -> pulumi.Input[int]:
        return pulumi.get(self, "days")

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


@pulumi.input_type
class BucketTopicConfigurationArgs:
    def __init__(__self__, *,
                 event: pulumi.Input[str],
                 topic: pulumi.Input[str],
                 filter: Optional[pulumi.Input['BucketNotificationFilterArgs']] = None):
        pulumi.set(__self__, "event", event)
        pulumi.set(__self__, "topic", topic)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)

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

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

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

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

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['BucketNotificationFilterArgs']]:
        return pulumi.get(self, "filter")

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


@pulumi.input_type
class BucketTransitionArgs:
    def __init__(__self__, *,
                 storage_class: pulumi.Input[str],
                 transition_date: Optional[pulumi.Input[str]] = None,
                 transition_in_days: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "storage_class", storage_class)
        if transition_date is not None:
            pulumi.set(__self__, "transition_date", transition_date)
        if transition_in_days is not None:
            pulumi.set(__self__, "transition_in_days", transition_in_days)

    @property
    @pulumi.getter(name="storageClass")
    def storage_class(self) -> pulumi.Input[str]:
        return pulumi.get(self, "storage_class")

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

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

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

    @property
    @pulumi.getter(name="transitionInDays")
    def transition_in_days(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "transition_in_days")

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


@pulumi.input_type
class BucketVersioningConfigurationArgs:
    def __init__(__self__, *,
                 status: pulumi.Input[str]):
        pulumi.set(__self__, "status", status)

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

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


@pulumi.input_type
class BucketWebsiteConfigurationArgs:
    def __init__(__self__, *,
                 error_document: Optional[pulumi.Input[str]] = None,
                 index_document: Optional[pulumi.Input[str]] = None,
                 redirect_all_requests_to: Optional[pulumi.Input['BucketRedirectAllRequestsToArgs']] = None,
                 routing_rules: Optional[pulumi.Input[Sequence[pulumi.Input['BucketRoutingRuleArgs']]]] = None):
        if error_document is not None:
            pulumi.set(__self__, "error_document", error_document)
        if index_document is not None:
            pulumi.set(__self__, "index_document", index_document)
        if redirect_all_requests_to is not None:
            pulumi.set(__self__, "redirect_all_requests_to", redirect_all_requests_to)
        if routing_rules is not None:
            pulumi.set(__self__, "routing_rules", routing_rules)

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

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

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

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

    @property
    @pulumi.getter(name="redirectAllRequestsTo")
    def redirect_all_requests_to(self) -> Optional[pulumi.Input['BucketRedirectAllRequestsToArgs']]:
        return pulumi.get(self, "redirect_all_requests_to")

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

    @property
    @pulumi.getter(name="routingRules")
    def routing_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BucketRoutingRuleArgs']]]]:
        return pulumi.get(self, "routing_rules")

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


@pulumi.input_type
class MultiRegionAccessPointPublicAccessBlockConfigurationArgs:
    def __init__(__self__, *,
                 block_public_acls: Optional[pulumi.Input[bool]] = None,
                 block_public_policy: Optional[pulumi.Input[bool]] = None,
                 ignore_public_acls: Optional[pulumi.Input[bool]] = None,
                 restrict_public_buckets: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] block_public_acls: Specifies whether Amazon S3 should block public access control lists (ACLs) for buckets in this account. Setting this element to TRUE causes the following behavior:
               - PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.
                - PUT Object calls fail if the request includes a public ACL.
               . - PUT Bucket calls fail if the request includes a public ACL.
               Enabling this setting doesn't affect existing policies or ACLs.
        :param pulumi.Input[bool] block_public_policy: Specifies whether Amazon S3 should block public bucket policies for buckets in this account. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access. Enabling this setting doesn't affect existing bucket policies.
        :param pulumi.Input[bool] ignore_public_acls: Specifies whether Amazon S3 should ignore public ACLs for buckets in this account. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on buckets in this account and any objects that they contain. Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
        :param pulumi.Input[bool] restrict_public_buckets: Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS services and authorized users within this account if the bucket has a public policy.
               Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
        """
        if block_public_acls is not None:
            pulumi.set(__self__, "block_public_acls", block_public_acls)
        if block_public_policy is not None:
            pulumi.set(__self__, "block_public_policy", block_public_policy)
        if ignore_public_acls is not None:
            pulumi.set(__self__, "ignore_public_acls", ignore_public_acls)
        if restrict_public_buckets is not None:
            pulumi.set(__self__, "restrict_public_buckets", restrict_public_buckets)

    @property
    @pulumi.getter(name="blockPublicAcls")
    def block_public_acls(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should block public access control lists (ACLs) for buckets in this account. Setting this element to TRUE causes the following behavior:
        - PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.
         - PUT Object calls fail if the request includes a public ACL.
        . - PUT Bucket calls fail if the request includes a public ACL.
        Enabling this setting doesn't affect existing policies or ACLs.
        """
        return pulumi.get(self, "block_public_acls")

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

    @property
    @pulumi.getter(name="blockPublicPolicy")
    def block_public_policy(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should block public bucket policies for buckets in this account. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access. Enabling this setting doesn't affect existing bucket policies.
        """
        return pulumi.get(self, "block_public_policy")

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

    @property
    @pulumi.getter(name="ignorePublicAcls")
    def ignore_public_acls(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should ignore public ACLs for buckets in this account. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on buckets in this account and any objects that they contain. Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
        """
        return pulumi.get(self, "ignore_public_acls")

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

    @property
    @pulumi.getter(name="restrictPublicBuckets")
    def restrict_public_buckets(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS services and authorized users within this account if the bucket has a public policy.
        Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
        """
        return pulumi.get(self, "restrict_public_buckets")

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


@pulumi.input_type
class MultiRegionAccessPointRegionArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str]):
        pulumi.set(__self__, "bucket", bucket)

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

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


@pulumi.input_type
class StorageLensAccountLevelArgs:
    def __init__(__self__, *,
                 bucket_level: pulumi.Input['StorageLensBucketLevelArgs'],
                 activity_metrics: Optional[pulumi.Input['StorageLensActivityMetricsArgs']] = None):
        """
        Account-level metrics configurations.
        """
        pulumi.set(__self__, "bucket_level", bucket_level)
        if activity_metrics is not None:
            pulumi.set(__self__, "activity_metrics", activity_metrics)

    @property
    @pulumi.getter(name="bucketLevel")
    def bucket_level(self) -> pulumi.Input['StorageLensBucketLevelArgs']:
        return pulumi.get(self, "bucket_level")

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

    @property
    @pulumi.getter(name="activityMetrics")
    def activity_metrics(self) -> Optional[pulumi.Input['StorageLensActivityMetricsArgs']]:
        return pulumi.get(self, "activity_metrics")

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


@pulumi.input_type
class StorageLensActivityMetricsArgs:
    def __init__(__self__, *,
                 is_enabled: Optional[pulumi.Input[bool]] = None):
        """
        Enables activity metrics.
        :param pulumi.Input[bool] is_enabled: Specifies whether activity metrics are enabled or disabled.
        """
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether activity metrics are enabled or disabled.
        """
        return pulumi.get(self, "is_enabled")

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


@pulumi.input_type
class StorageLensAwsOrgArgs:
    def __init__(__self__, *,
                 arn: pulumi.Input[str]):
        """
        The AWS Organizations ARN to use in the Amazon S3 Storage Lens configuration.
        """
        pulumi.set(__self__, "arn", arn)

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

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


@pulumi.input_type
class StorageLensBucketLevelArgs:
    def __init__(__self__, *,
                 activity_metrics: Optional[pulumi.Input['StorageLensActivityMetricsArgs']] = None,
                 prefix_level: Optional[pulumi.Input['StorageLensPrefixLevelArgs']] = None):
        """
        Bucket-level metrics configurations.
        """
        if activity_metrics is not None:
            pulumi.set(__self__, "activity_metrics", activity_metrics)
        if prefix_level is not None:
            pulumi.set(__self__, "prefix_level", prefix_level)

    @property
    @pulumi.getter(name="activityMetrics")
    def activity_metrics(self) -> Optional[pulumi.Input['StorageLensActivityMetricsArgs']]:
        return pulumi.get(self, "activity_metrics")

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

    @property
    @pulumi.getter(name="prefixLevel")
    def prefix_level(self) -> Optional[pulumi.Input['StorageLensPrefixLevelArgs']]:
        return pulumi.get(self, "prefix_level")

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


@pulumi.input_type
class StorageLensBucketsAndRegionsArgs:
    def __init__(__self__, *,
                 buckets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        S3 buckets and Regions to include/exclude in the Amazon S3 Storage Lens configuration.
        """
        if buckets is not None:
            pulumi.set(__self__, "buckets", buckets)
        if regions is not None:
            pulumi.set(__self__, "regions", regions)

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

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

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

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


@pulumi.input_type
class StorageLensDataExportArgs:
    def __init__(__self__, *,
                 s3_bucket_destination: pulumi.Input['StorageLensS3BucketDestinationArgs']):
        """
        Specifies how Amazon S3 Storage Lens metrics should be exported.
        """
        pulumi.set(__self__, "s3_bucket_destination", s3_bucket_destination)

    @property
    @pulumi.getter(name="s3BucketDestination")
    def s3_bucket_destination(self) -> pulumi.Input['StorageLensS3BucketDestinationArgs']:
        return pulumi.get(self, "s3_bucket_destination")

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


@pulumi.input_type
class StorageLensEncryptionArgs:
    def __init__(__self__):
        """
        Configures the server-side encryption for Amazon S3 Storage Lens report files with either S3-managed keys (SSE-S3) or KMS-managed keys (SSE-KMS).
        """
        pass


@pulumi.input_type
class StorageLensPrefixLevelStorageMetricsArgs:
    def __init__(__self__, *,
                 is_enabled: Optional[pulumi.Input[bool]] = None,
                 selection_criteria: Optional[pulumi.Input['StorageLensSelectionCriteriaArgs']] = None):
        """
        :param pulumi.Input[bool] is_enabled: Specifies whether prefix-level storage metrics are enabled or disabled.
        """
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if selection_criteria is not None:
            pulumi.set(__self__, "selection_criteria", selection_criteria)

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether prefix-level storage metrics are enabled or disabled.
        """
        return pulumi.get(self, "is_enabled")

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

    @property
    @pulumi.getter(name="selectionCriteria")
    def selection_criteria(self) -> Optional[pulumi.Input['StorageLensSelectionCriteriaArgs']]:
        return pulumi.get(self, "selection_criteria")

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


@pulumi.input_type
class StorageLensPrefixLevelArgs:
    def __init__(__self__, *,
                 storage_metrics: pulumi.Input['StorageLensPrefixLevelStorageMetricsArgs']):
        """
        Prefix-level metrics configurations.
        """
        pulumi.set(__self__, "storage_metrics", storage_metrics)

    @property
    @pulumi.getter(name="storageMetrics")
    def storage_metrics(self) -> pulumi.Input['StorageLensPrefixLevelStorageMetricsArgs']:
        return pulumi.get(self, "storage_metrics")

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


@pulumi.input_type
class StorageLensS3BucketDestinationArgs:
    def __init__(__self__, *,
                 account_id: pulumi.Input[str],
                 arn: pulumi.Input[str],
                 format: pulumi.Input['StorageLensS3BucketDestinationFormat'],
                 output_schema_version: pulumi.Input['StorageLensS3BucketDestinationOutputSchemaVersion'],
                 encryption: Optional[pulumi.Input['StorageLensEncryptionArgs']] = None,
                 prefix: Optional[pulumi.Input[str]] = None):
        """
        S3 bucket destination settings for the Amazon S3 Storage Lens metrics export.
        :param pulumi.Input[str] account_id: The AWS account ID that owns the destination S3 bucket.
        :param pulumi.Input[str] arn: The ARN of the bucket to which Amazon S3 Storage Lens exports will be placed.
        :param pulumi.Input['StorageLensS3BucketDestinationFormat'] format: Specifies the file format to use when exporting Amazon S3 Storage Lens metrics export.
        :param pulumi.Input['StorageLensS3BucketDestinationOutputSchemaVersion'] output_schema_version: The version of the output schema to use when exporting Amazon S3 Storage Lens metrics.
        :param pulumi.Input[str] prefix: The prefix to use for Amazon S3 Storage Lens export.
        """
        pulumi.set(__self__, "account_id", account_id)
        pulumi.set(__self__, "arn", arn)
        pulumi.set(__self__, "format", format)
        pulumi.set(__self__, "output_schema_version", output_schema_version)
        if encryption is not None:
            pulumi.set(__self__, "encryption", encryption)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> pulumi.Input[str]:
        """
        The AWS account ID that owns the destination S3 bucket.
        """
        return pulumi.get(self, "account_id")

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

    @property
    @pulumi.getter
    def arn(self) -> pulumi.Input[str]:
        """
        The ARN of the bucket to which Amazon S3 Storage Lens exports will be placed.
        """
        return pulumi.get(self, "arn")

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

    @property
    @pulumi.getter
    def format(self) -> pulumi.Input['StorageLensS3BucketDestinationFormat']:
        """
        Specifies the file format to use when exporting Amazon S3 Storage Lens metrics export.
        """
        return pulumi.get(self, "format")

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

    @property
    @pulumi.getter(name="outputSchemaVersion")
    def output_schema_version(self) -> pulumi.Input['StorageLensS3BucketDestinationOutputSchemaVersion']:
        """
        The version of the output schema to use when exporting Amazon S3 Storage Lens metrics.
        """
        return pulumi.get(self, "output_schema_version")

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

    @property
    @pulumi.getter
    def encryption(self) -> Optional[pulumi.Input['StorageLensEncryptionArgs']]:
        return pulumi.get(self, "encryption")

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

    @property
    @pulumi.getter
    def prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix to use for Amazon S3 Storage Lens export.
        """
        return pulumi.get(self, "prefix")

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


@pulumi.input_type
class StorageLensSelectionCriteriaArgs:
    def __init__(__self__, *,
                 delimiter: Optional[pulumi.Input[str]] = None,
                 max_depth: Optional[pulumi.Input[int]] = None,
                 min_storage_bytes_percentage: Optional[pulumi.Input[float]] = None):
        """
        Selection criteria for prefix-level metrics.
        :param pulumi.Input[str] delimiter: Delimiter to divide S3 key into hierarchy of prefixes.
        :param pulumi.Input[int] max_depth: Max depth of prefixes of S3 key that Amazon S3 Storage Lens will analyze.
        :param pulumi.Input[float] min_storage_bytes_percentage: The minimum storage bytes threshold for the prefixes to be included in the analysis.
        """
        if delimiter is not None:
            pulumi.set(__self__, "delimiter", delimiter)
        if max_depth is not None:
            pulumi.set(__self__, "max_depth", max_depth)
        if min_storage_bytes_percentage is not None:
            pulumi.set(__self__, "min_storage_bytes_percentage", min_storage_bytes_percentage)

    @property
    @pulumi.getter
    def delimiter(self) -> Optional[pulumi.Input[str]]:
        """
        Delimiter to divide S3 key into hierarchy of prefixes.
        """
        return pulumi.get(self, "delimiter")

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

    @property
    @pulumi.getter(name="maxDepth")
    def max_depth(self) -> Optional[pulumi.Input[int]]:
        """
        Max depth of prefixes of S3 key that Amazon S3 Storage Lens will analyze.
        """
        return pulumi.get(self, "max_depth")

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

    @property
    @pulumi.getter(name="minStorageBytesPercentage")
    def min_storage_bytes_percentage(self) -> Optional[pulumi.Input[float]]:
        """
        The minimum storage bytes threshold for the prefixes to be included in the analysis.
        """
        return pulumi.get(self, "min_storage_bytes_percentage")

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


@pulumi.input_type
class StorageLensStorageLensConfigurationArgs:
    def __init__(__self__, *,
                 account_level: pulumi.Input['StorageLensAccountLevelArgs'],
                 id: pulumi.Input[str],
                 is_enabled: pulumi.Input[bool],
                 aws_org: Optional[pulumi.Input['StorageLensAwsOrgArgs']] = None,
                 data_export: Optional[pulumi.Input['StorageLensDataExportArgs']] = None,
                 exclude: Optional[pulumi.Input['StorageLensBucketsAndRegionsArgs']] = None,
                 include: Optional[pulumi.Input['StorageLensBucketsAndRegionsArgs']] = None,
                 storage_lens_arn: Optional[pulumi.Input[str]] = None):
        """
        Specifies the details of Amazon S3 Storage Lens configuration.
        :param pulumi.Input[bool] is_enabled: Specifies whether the Amazon S3 Storage Lens configuration is enabled or disabled.
        :param pulumi.Input[str] storage_lens_arn: The ARN for the Amazon S3 Storage Lens configuration.
        """
        pulumi.set(__self__, "account_level", account_level)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_enabled", is_enabled)
        if aws_org is not None:
            pulumi.set(__self__, "aws_org", aws_org)
        if data_export is not None:
            pulumi.set(__self__, "data_export", data_export)
        if exclude is not None:
            pulumi.set(__self__, "exclude", exclude)
        if include is not None:
            pulumi.set(__self__, "include", include)
        if storage_lens_arn is not None:
            pulumi.set(__self__, "storage_lens_arn", storage_lens_arn)

    @property
    @pulumi.getter(name="accountLevel")
    def account_level(self) -> pulumi.Input['StorageLensAccountLevelArgs']:
        return pulumi.get(self, "account_level")

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

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

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

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> pulumi.Input[bool]:
        """
        Specifies whether the Amazon S3 Storage Lens configuration is enabled or disabled.
        """
        return pulumi.get(self, "is_enabled")

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

    @property
    @pulumi.getter(name="awsOrg")
    def aws_org(self) -> Optional[pulumi.Input['StorageLensAwsOrgArgs']]:
        return pulumi.get(self, "aws_org")

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

    @property
    @pulumi.getter(name="dataExport")
    def data_export(self) -> Optional[pulumi.Input['StorageLensDataExportArgs']]:
        return pulumi.get(self, "data_export")

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

    @property
    @pulumi.getter
    def exclude(self) -> Optional[pulumi.Input['StorageLensBucketsAndRegionsArgs']]:
        return pulumi.get(self, "exclude")

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

    @property
    @pulumi.getter
    def include(self) -> Optional[pulumi.Input['StorageLensBucketsAndRegionsArgs']]:
        return pulumi.get(self, "include")

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

    @property
    @pulumi.getter(name="storageLensArn")
    def storage_lens_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN for the Amazon S3 Storage Lens configuration.
        """
        return pulumi.get(self, "storage_lens_arn")

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


@pulumi.input_type
class StorageLensTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


