@aws-sdk/client-s3/dist-types/ts3.4/models/models_0.d.ts

AWS SDK for JavaScript S3 Client for Node.js, Browser and React Native

import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
import { Readable } from "stream";
import { S3ServiceException as __BaseException } from "./S3ServiceException";

export interface AbortIncompleteMultipartUpload {
    
    DaysAfterInitiation?: number;
}
export declare namespace AbortIncompleteMultipartUpload {
    
    const filterSensitiveLog: (obj: AbortIncompleteMultipartUpload) => any;
}
export declare type RequestCharged = "requester";
export interface AbortMultipartUploadOutput {
    
    RequestCharged?: RequestCharged | string;
}
export declare namespace AbortMultipartUploadOutput {
    
    const filterSensitiveLog: (obj: AbortMultipartUploadOutput) => any;
}
export declare type RequestPayer = "requester";
export interface AbortMultipartUploadRequest {
    
    Bucket: string | undefined;
    
    Key: string | undefined;
    
    UploadId: string | undefined;
    
    RequestPayer?: RequestPayer | string;
    
    ExpectedBucketOwner?: string;
}
export declare namespace AbortMultipartUploadRequest {
    
    const filterSensitiveLog: (obj: AbortMultipartUploadRequest) => any;
}

export declare class NoSuchUpload extends __BaseException {
    readonly name: "NoSuchUpload";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<NoSuchUpload, __BaseException>);
}
export declare type BucketAccelerateStatus = "Enabled" | "Suspended";

export interface AccelerateConfiguration {
    
    Status?: BucketAccelerateStatus | string;
}
export declare namespace AccelerateConfiguration {
    
    const filterSensitiveLog: (obj: AccelerateConfiguration) => any;
}
export declare type Type = "AmazonCustomerByEmail" | "CanonicalUser" | "Group";

export interface Grantee {
    
    DisplayName?: string;
    
    EmailAddress?: string;
    
    ID?: string;
    
    URI?: string;
    
    Type: Type | string | undefined;
}
export declare namespace Grantee {
    
    const filterSensitiveLog: (obj: Grantee) => any;
}
export declare type Permission = "FULL_CONTROL" | "READ" | "READ_ACP" | "WRITE" | "WRITE_ACP";

export interface Grant {
    
    Grantee?: Grantee;
    
    Permission?: Permission | string;
}
export declare namespace Grant {
    
    const filterSensitiveLog: (obj: Grant) => any;
}

export interface Owner {
    
    DisplayName?: string;
    
    ID?: string;
}
export declare namespace Owner {
    
    const filterSensitiveLog: (obj: Owner) => any;
}

export interface AccessControlPolicy {
    
    Grants?: Grant[];
    
    Owner?: Owner;
}
export declare namespace AccessControlPolicy {
    
    const filterSensitiveLog: (obj: AccessControlPolicy) => any;
}
export declare type OwnerOverride = "Destination";

export interface AccessControlTranslation {
    
    Owner: OwnerOverride | string | undefined;
}
export declare namespace AccessControlTranslation {
    
    const filterSensitiveLog: (obj: AccessControlTranslation) => any;
}
export declare type ServerSideEncryption = "AES256" | "aws:kms";
export interface CompleteMultipartUploadOutput {
    
    Location?: string;
    
    Bucket?: string;
    
    Key?: string;
    
    Expiration?: string;
    
    ETag?: string;
    
    ChecksumCRC32?: string;
    
    ChecksumCRC32C?: string;
    
    ChecksumSHA1?: string;
    
    ChecksumSHA256?: string;
    
    ServerSideEncryption?: ServerSideEncryption | string;
    
    VersionId?: string;
    
    SSEKMSKeyId?: string;
    
    BucketKeyEnabled?: boolean;
    
    RequestCharged?: RequestCharged | string;
}
export declare namespace CompleteMultipartUploadOutput {
    
    const filterSensitiveLog: (obj: CompleteMultipartUploadOutput) => any;
}

export interface CompletedPart {
    
    ETag?: string;
    
    ChecksumCRC32?: string;
    
    ChecksumCRC32C?: string;
    
    ChecksumSHA1?: string;
    
    ChecksumSHA256?: string;
    
    PartNumber?: number;
}
export declare namespace CompletedPart {
    
    const filterSensitiveLog: (obj: CompletedPart) => any;
}

export interface CompletedMultipartUpload {
    
    Parts?: CompletedPart[];
}
export declare namespace CompletedMultipartUpload {
    
    const filterSensitiveLog: (obj: CompletedMultipartUpload) => any;
}
export interface CompleteMultipartUploadRequest {
    
    Bucket: string | undefined;
    
    Key: string | undefined;
    
    MultipartUpload?: CompletedMultipartUpload;
    
    UploadId: string | undefined;
    
    ChecksumCRC32?: string;
    
    ChecksumCRC32C?: string;
    
    ChecksumSHA1?: string;
    
    ChecksumSHA256?: string;
    
    RequestPayer?: RequestPayer | string;
    
    ExpectedBucketOwner?: string;
    
    SSECustomerAlgorithm?: string;
    
    SSECustomerKey?: string;
    
    SSECustomerKeyMD5?: string;
}
export declare namespace CompleteMultipartUploadRequest {
    
    const filterSensitiveLog: (obj: CompleteMultipartUploadRequest) => any;
}

export interface CopyObjectResult {
    
    ETag?: string;
    
    LastModified?: Date;
    
    ChecksumCRC32?: string;
    
    ChecksumCRC32C?: string;
    
    ChecksumSHA1?: string;
    
    ChecksumSHA256?: string;
}
export declare namespace CopyObjectResult {
    
    const filterSensitiveLog: (obj: CopyObjectResult) => any;
}
export interface CopyObjectOutput {
    
    CopyObjectResult?: CopyObjectResult;
    
    Expiration?: string;
    
    CopySourceVersionId?: string;
    
    VersionId?: string;
    
    ServerSideEncryption?: ServerSideEncryption | string;
    
    SSECustomerAlgorithm?: string;
    
    SSECustomerKeyMD5?: string;
    
    SSEKMSKeyId?: string;
    
    SSEKMSEncryptionContext?: string;
    
    BucketKeyEnabled?: boolean;
    
    RequestCharged?: RequestCharged | string;
}
export declare namespace CopyObjectOutput {
    
    const filterSensitiveLog: (obj: CopyObjectOutput) => any;
}
export declare type ObjectCannedACL = "authenticated-read" | "aws-exec-read" | "bucket-owner-full-control" | "bucket-owner-read" | "private" | "public-read" | "public-read-write";
export declare enum ChecksumAlgorithm {
    CRC32 = "CRC32",
    CRC32C = "CRC32C",
    SHA1 = "SHA1",
    SHA256 = "SHA256"
}
export declare type MetadataDirective = "COPY" | "REPLACE";
export declare type ObjectLockLegalHoldStatus = "OFF" | "ON";
export declare type ObjectLockMode = "COMPLIANCE" | "GOVERNANCE";
export declare type StorageClass = "DEEP_ARCHIVE" | "GLACIER" | "GLACIER_IR" | "INTELLIGENT_TIERING" | "ONEZONE_IA" | "OUTPOSTS" | "REDUCED_REDUNDANCY" | "STANDARD" | "STANDARD_IA";
export declare type TaggingDirective = "COPY" | "REPLACE";
export interface CopyObjectRequest {
    
    ACL?: ObjectCannedACL | string;
    
    Bucket: string | undefined;
    
    CacheControl?: string;
    
    ChecksumAlgorithm?: ChecksumAlgorithm | string;
    
    ContentDisposition?: string;
    
    ContentEncoding?: string;
    
    ContentLanguage?: string;
    
    ContentType?: string;
    
    CopySource: string | undefined;
    
    CopySourceIfMatch?: string;
    
    CopySourceIfModifiedSince?: Date;
    
    CopySourceIfNoneMatch?: string;
    
    CopySourceIfUnmodifiedSince?: Date;
    
    Expires?: Date;
    
    GrantFullControl?: string;
    
    GrantRead?: string;
    
    GrantReadACP?: string;
    
    GrantWriteACP?: string;
    
    Key: string | undefined;
    
    Metadata?: Record<string, string>;
    
    MetadataDirective?: MetadataDirective | string;
    
    TaggingDirective?: TaggingDirective | string;
    
    ServerSideEncryption?: ServerSideEncryption | string;
    
    StorageClass?: StorageClass | string;
    
    WebsiteRedirectLocation?: string;
    
    SSECustomerAlgorithm?: string;
    
    SSECustomerKey?: string;
    
    SSECustomerKeyMD5?: string;
    
    SSEKMSKeyId?: string;
    
    SSEKMSEncryptionContext?: string;
    
    BucketKeyEnabled?: boolean;
    
    CopySourceSSECustomerAlgorithm?: string;
    
    CopySourceSSECustomerKey?: string;
    
    CopySourceSSECustomerKeyMD5?: string;
    
    RequestPayer?: RequestPayer | string;
    
    Tagging?: string;
    
    ObjectLockMode?: ObjectLockMode | string;
    
    ObjectLockRetainUntilDate?: Date;
    
    ObjectLockLegalHoldStatus?: ObjectLockLegalHoldStatus | string;
    
    ExpectedBucketOwner?: string;
    
    ExpectedSourceBucketOwner?: string;
}
export declare namespace CopyObjectRequest {
    
    const filterSensitiveLog: (obj: CopyObjectRequest) => any;
}

export declare class ObjectNotInActiveTierError extends __BaseException {
    readonly name: "ObjectNotInActiveTierError";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ObjectNotInActiveTierError, __BaseException>);
}

export declare class BucketAlreadyExists extends __BaseException {
    readonly name: "BucketAlreadyExists";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<BucketAlreadyExists, __BaseException>);
}

export declare class BucketAlreadyOwnedByYou extends __BaseException {
    readonly name: "BucketAlreadyOwnedByYou";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<BucketAlreadyOwnedByYou, __BaseException>);
}
export interface CreateBucketOutput {
    
    Location?: string;
}
export declare namespace CreateBucketOutput {
    
    const filterSensitiveLog: (obj: CreateBucketOutput) => any;
}
export declare type BucketCannedACL = "authenticated-read" | "private" | "public-read" | "public-read-write";
export declare type BucketLocationConstraint = "EU" | "af-south-1" | "ap-east-1" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ap-south-1" | "ap-southeast-1" | "ap-southeast-2" | "ca-central-1" | "cn-north-1" | "cn-northwest-1" | "eu-central-1" | "eu-north-1" | "eu-south-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "me-south-1" | "sa-east-1" | "us-east-2" | "us-gov-east-1" | "us-gov-west-1" | "us-west-1" | "us-west-2";

export interface CreateBucketConfiguration {
    
    LocationConstraint?: BucketLocationConstraint | string;
}
export declare namespace CreateBucketConfiguration {
    
    const filterSensitiveLog: (obj: CreateBucketConfiguration) => any;
}
export declare type ObjectOwnership = "BucketOwnerEnforced" | "BucketOwnerPreferred" | "ObjectWriter";
export interface CreateBucketRequest {
    
    ACL?: BucketCannedACL | string;
    
    Bucket: string | undefined;
    
    CreateBucketConfiguration?: CreateBucketConfiguration;
    
    GrantFullControl?: string;
    
    GrantRead?: string;
    
    GrantReadACP?: string;
    
    GrantWrite?: string;
    
    GrantWriteACP?: string;
    
    ObjectLockEnabledForBucket?: boolean;
    
    ObjectOwnership?: ObjectOwnership | string;
}
export declare namespace CreateBucketRequest {
    
    const filterSensitiveLog: (obj: CreateBucketRequest) => any;
}
export interface CreateMultipartUploadOutput {
    
    AbortDate?: Date;
    
    AbortRuleId?: string;
    
    Bucket?: string;
    
    Key?: string;
    
    UploadId?: string;
    
    ServerSideEncryption?: ServerSideEncryption | string;
    
    SSECustomerAlgorithm?: string;
    
    SSECustomerKeyMD5?: string;
    
    SSEKMSKeyId?: string;
    
    SSEKMSEncryptionContext?: string;
    
    BucketKeyEnabled?: boolean;
    
    RequestCharged?: RequestCharged | string;
    
    ChecksumAlgorithm?: ChecksumAlgorithm | string;
}
export declare namespace CreateMultipartUploadOutput {
    
    const filterSensitiveLog: (obj: CreateMultipartUploadOutput) => any;
}
export interface CreateMultipartUploadRequest {
    
    ACL?: ObjectCannedACL | string;
    
    Bucket: string | undefined;
    
    CacheControl?: string;
    
    ContentDisposition?: string;
    
    ContentEncoding?: string;
    
    ContentLanguage?: string;
    
    ContentType?: string;
    
    Expires?: Date;
    
    GrantFullControl?: string;
    
    GrantRead?: string;
    
    GrantReadACP?: string;
    
    GrantWriteACP?: string;
    
    Key: string | undefined;
    
    Metadata?: Record<string, string>;
    
    ServerSideEncryption?: ServerSideEncryption | string;
    
    StorageClass?: StorageClass | string;
    
    WebsiteRedirectLocation?: string;
    
    SSECustomerAlgorithm?: string;
    
    SSECustomerKey?: string;
    
    SSECustomerKeyMD5?: string;
    
    SSEKMSKeyId?: string;
    
    SSEKMSEncryptionContext?: string;
    
    BucketKeyEnabled?: boolean;
    
    RequestPayer?: RequestPayer | string;
    
    Tagging?: string;
    
    ObjectLockMode?: ObjectLockMode | string;
    
    ObjectLockRetainUntilDate?: Date;
    
    ObjectLockLegalHoldStatus?: ObjectLockLegalHoldStatus | string;
    
    ExpectedBucketOwner?: string;
    
    ChecksumAlgorithm?: ChecksumAlgorithm | string;
}
export declare namespace CreateMultipartUploadRequest {
    
    const filterSensitiveLog: (obj: CreateMultipartUploadRequest) => any;
}
export interface DeleteBucketRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketRequest) => any;
}
export interface DeleteBucketAnalyticsConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketAnalyticsConfigurationRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketAnalyticsConfigurationRequest) => any;
}
export interface DeleteBucketCorsRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketCorsRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketCorsRequest) => any;
}
export interface DeleteBucketEncryptionRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketEncryptionRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketEncryptionRequest) => any;
}
export interface DeleteBucketIntelligentTieringConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
}
export declare namespace DeleteBucketIntelligentTieringConfigurationRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketIntelligentTieringConfigurationRequest) => any;
}
export interface DeleteBucketInventoryConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketInventoryConfigurationRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketInventoryConfigurationRequest) => any;
}
export interface DeleteBucketLifecycleRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketLifecycleRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketLifecycleRequest) => any;
}
export interface DeleteBucketMetricsConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketMetricsConfigurationRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketMetricsConfigurationRequest) => any;
}
export interface DeleteBucketOwnershipControlsRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketOwnershipControlsRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketOwnershipControlsRequest) => any;
}
export interface DeleteBucketPolicyRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketPolicyRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketPolicyRequest) => any;
}
export interface DeleteBucketReplicationRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketReplicationRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketReplicationRequest) => any;
}
export interface DeleteBucketTaggingRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketTaggingRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketTaggingRequest) => any;
}
export interface DeleteBucketWebsiteRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteBucketWebsiteRequest {
    
    const filterSensitiveLog: (obj: DeleteBucketWebsiteRequest) => any;
}
export interface DeleteObjectOutput {
    
    DeleteMarker?: boolean;
    
    VersionId?: string;
    
    RequestCharged?: RequestCharged | string;
}
export declare namespace DeleteObjectOutput {
    
    const filterSensitiveLog: (obj: DeleteObjectOutput) => any;
}
export interface DeleteObjectRequest {
    
    Bucket: string | undefined;
    
    Key: string | undefined;
    
    MFA?: string;
    
    VersionId?: string;
    
    RequestPayer?: RequestPayer | string;
    
    BypassGovernanceRetention?: boolean;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteObjectRequest {
    
    const filterSensitiveLog: (obj: DeleteObjectRequest) => any;
}

export interface DeletedObject {
    
    Key?: string;
    
    VersionId?: string;
    
    DeleteMarker?: boolean;
    
    DeleteMarkerVersionId?: string;
}
export declare namespace DeletedObject {
    
    const filterSensitiveLog: (obj: DeletedObject) => any;
}

export interface _Error {
    
    Key?: string;
    
    VersionId?: string;
    
    Code?: string;
    
    Message?: string;
}
export declare namespace _Error {
    
    const filterSensitiveLog: (obj: _Error) => any;
}
export interface DeleteObjectsOutput {
    
    Deleted?: DeletedObject[];
    
    RequestCharged?: RequestCharged | string;
    
    Errors?: _Error[];
}
export declare namespace DeleteObjectsOutput {
    
    const filterSensitiveLog: (obj: DeleteObjectsOutput) => any;
}

export interface ObjectIdentifier {
    
    Key: string | undefined;
    
    VersionId?: string;
}
export declare namespace ObjectIdentifier {
    
    const filterSensitiveLog: (obj: ObjectIdentifier) => any;
}

export interface Delete {
    
    Objects: ObjectIdentifier[] | undefined;
    
    Quiet?: boolean;
}
export declare namespace Delete {
    
    const filterSensitiveLog: (obj: Delete) => any;
}
export interface DeleteObjectsRequest {
    
    Bucket: string | undefined;
    
    Delete: Delete | undefined;
    
    MFA?: string;
    
    RequestPayer?: RequestPayer | string;
    
    BypassGovernanceRetention?: boolean;
    
    ExpectedBucketOwner?: string;
    
    ChecksumAlgorithm?: ChecksumAlgorithm | string;
}
export declare namespace DeleteObjectsRequest {
    
    const filterSensitiveLog: (obj: DeleteObjectsRequest) => any;
}
export interface DeleteObjectTaggingOutput {
    
    VersionId?: string;
}
export declare namespace DeleteObjectTaggingOutput {
    
    const filterSensitiveLog: (obj: DeleteObjectTaggingOutput) => any;
}
export interface DeleteObjectTaggingRequest {
    
    Bucket: string | undefined;
    
    Key: string | undefined;
    
    VersionId?: string;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeleteObjectTaggingRequest {
    
    const filterSensitiveLog: (obj: DeleteObjectTaggingRequest) => any;
}
export interface DeletePublicAccessBlockRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace DeletePublicAccessBlockRequest {
    
    const filterSensitiveLog: (obj: DeletePublicAccessBlockRequest) => any;
}
export interface GetBucketAccelerateConfigurationOutput {
    
    Status?: BucketAccelerateStatus | string;
}
export declare namespace GetBucketAccelerateConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketAccelerateConfigurationOutput) => any;
}
export interface GetBucketAccelerateConfigurationRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketAccelerateConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketAccelerateConfigurationRequest) => any;
}
export interface GetBucketAclOutput {
    
    Owner?: Owner;
    
    Grants?: Grant[];
}
export declare namespace GetBucketAclOutput {
    
    const filterSensitiveLog: (obj: GetBucketAclOutput) => any;
}
export interface GetBucketAclRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketAclRequest {
    
    const filterSensitiveLog: (obj: GetBucketAclRequest) => any;
}

export interface Tag {
    
    Key: string | undefined;
    
    Value: string | undefined;
}
export declare namespace Tag {
    
    const filterSensitiveLog: (obj: Tag) => any;
}

export interface AnalyticsAndOperator {
    
    Prefix?: string;
    
    Tags?: Tag[];
}
export declare namespace AnalyticsAndOperator {
    
    const filterSensitiveLog: (obj: AnalyticsAndOperator) => any;
}

export declare type AnalyticsFilter = AnalyticsFilter.AndMember | AnalyticsFilter.PrefixMember | AnalyticsFilter.TagMember | AnalyticsFilter.$UnknownMember;
export declare namespace AnalyticsFilter {
    
    interface PrefixMember {
        Prefix: string;
        Tag?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface TagMember {
        Prefix?: never;
        Tag: Tag;
        And?: never;
        $unknown?: never;
    }
    
    interface AndMember {
        Prefix?: never;
        Tag?: never;
        And: AnalyticsAndOperator;
        $unknown?: never;
    }
    interface $UnknownMember {
        Prefix?: never;
        Tag?: never;
        And?: never;
        $unknown: [
            string,
            any
        ];
    }
    interface Visitor<T> {
        Prefix: (value: string) => T;
        Tag: (value: Tag) => T;
        And: (value: AnalyticsAndOperator) => T;
        _: (name: string, value: any) => T;
    }
    const visit: <T>(value: AnalyticsFilter, visitor: Visitor<T>) => T;
    
    const filterSensitiveLog: (obj: AnalyticsFilter) => any;
}
export declare type AnalyticsS3ExportFileFormat = "CSV";

export interface AnalyticsS3BucketDestination {
    
    Format: AnalyticsS3ExportFileFormat | string | undefined;
    
    BucketAccountId?: string;
    
    Bucket: string | undefined;
    
    Prefix?: string;
}
export declare namespace AnalyticsS3BucketDestination {
    
    const filterSensitiveLog: (obj: AnalyticsS3BucketDestination) => any;
}

export interface AnalyticsExportDestination {
    
    S3BucketDestination: AnalyticsS3BucketDestination | undefined;
}
export declare namespace AnalyticsExportDestination {
    
    const filterSensitiveLog: (obj: AnalyticsExportDestination) => any;
}
export declare type StorageClassAnalysisSchemaVersion = "V_1";

export interface StorageClassAnalysisDataExport {
    
    OutputSchemaVersion: StorageClassAnalysisSchemaVersion | string | undefined;
    
    Destination: AnalyticsExportDestination | undefined;
}
export declare namespace StorageClassAnalysisDataExport {
    
    const filterSensitiveLog: (obj: StorageClassAnalysisDataExport) => any;
}

export interface StorageClassAnalysis {
    
    DataExport?: StorageClassAnalysisDataExport;
}
export declare namespace StorageClassAnalysis {
    
    const filterSensitiveLog: (obj: StorageClassAnalysis) => any;
}

export interface AnalyticsConfiguration {
    
    Id: string | undefined;
    
    Filter?: AnalyticsFilter;
    
    StorageClassAnalysis: StorageClassAnalysis | undefined;
}
export declare namespace AnalyticsConfiguration {
    
    const filterSensitiveLog: (obj: AnalyticsConfiguration) => any;
}
export interface GetBucketAnalyticsConfigurationOutput {
    
    AnalyticsConfiguration?: AnalyticsConfiguration;
}
export declare namespace GetBucketAnalyticsConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketAnalyticsConfigurationOutput) => any;
}
export interface GetBucketAnalyticsConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketAnalyticsConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketAnalyticsConfigurationRequest) => any;
}

export interface CORSRule {
    
    ID?: string;
    
    AllowedHeaders?: string[];
    
    AllowedMethods: string[] | undefined;
    
    AllowedOrigins: string[] | undefined;
    
    ExposeHeaders?: string[];
    
    MaxAgeSeconds?: number;
}
export declare namespace CORSRule {
    
    const filterSensitiveLog: (obj: CORSRule) => any;
}
export interface GetBucketCorsOutput {
    
    CORSRules?: CORSRule[];
}
export declare namespace GetBucketCorsOutput {
    
    const filterSensitiveLog: (obj: GetBucketCorsOutput) => any;
}
export interface GetBucketCorsRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketCorsRequest {
    
    const filterSensitiveLog: (obj: GetBucketCorsRequest) => any;
}

export interface ServerSideEncryptionByDefault {
    
    SSEAlgorithm: ServerSideEncryption | string | undefined;
    
    KMSMasterKeyID?: string;
}
export declare namespace ServerSideEncryptionByDefault {
    
    const filterSensitiveLog: (obj: ServerSideEncryptionByDefault) => any;
}

export interface ServerSideEncryptionRule {
    
    ApplyServerSideEncryptionByDefault?: ServerSideEncryptionByDefault;
    
    BucketKeyEnabled?: boolean;
}
export declare namespace ServerSideEncryptionRule {
    
    const filterSensitiveLog: (obj: ServerSideEncryptionRule) => any;
}

export interface ServerSideEncryptionConfiguration {
    
    Rules: ServerSideEncryptionRule[] | undefined;
}
export declare namespace ServerSideEncryptionConfiguration {
    
    const filterSensitiveLog: (obj: ServerSideEncryptionConfiguration) => any;
}
export interface GetBucketEncryptionOutput {
    
    ServerSideEncryptionConfiguration?: ServerSideEncryptionConfiguration;
}
export declare namespace GetBucketEncryptionOutput {
    
    const filterSensitiveLog: (obj: GetBucketEncryptionOutput) => any;
}
export interface GetBucketEncryptionRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketEncryptionRequest {
    
    const filterSensitiveLog: (obj: GetBucketEncryptionRequest) => any;
}

export interface IntelligentTieringAndOperator {
    
    Prefix?: string;
    
    Tags?: Tag[];
}
export declare namespace IntelligentTieringAndOperator {
    
    const filterSensitiveLog: (obj: IntelligentTieringAndOperator) => any;
}

export interface IntelligentTieringFilter {
    
    Prefix?: string;
    
    Tag?: Tag;
    
    And?: IntelligentTieringAndOperator;
}
export declare namespace IntelligentTieringFilter {
    
    const filterSensitiveLog: (obj: IntelligentTieringFilter) => any;
}
export declare type IntelligentTieringStatus = "Disabled" | "Enabled";
export declare type IntelligentTieringAccessTier = "ARCHIVE_ACCESS" | "DEEP_ARCHIVE_ACCESS";

export interface Tiering {
    
    Days: number | undefined;
    
    AccessTier: IntelligentTieringAccessTier | string | undefined;
}
export declare namespace Tiering {
    
    const filterSensitiveLog: (obj: Tiering) => any;
}

export interface IntelligentTieringConfiguration {
    
    Id: string | undefined;
    
    Filter?: IntelligentTieringFilter;
    
    Status: IntelligentTieringStatus | string | undefined;
    
    Tierings: Tiering[] | undefined;
}
export declare namespace IntelligentTieringConfiguration {
    
    const filterSensitiveLog: (obj: IntelligentTieringConfiguration) => any;
}
export interface GetBucketIntelligentTieringConfigurationOutput {
    
    IntelligentTieringConfiguration?: IntelligentTieringConfiguration;
}
export declare namespace GetBucketIntelligentTieringConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketIntelligentTieringConfigurationOutput) => any;
}
export interface GetBucketIntelligentTieringConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
}
export declare namespace GetBucketIntelligentTieringConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketIntelligentTieringConfigurationRequest) => any;
}

export interface SSEKMS {
    
    KeyId: string | undefined;
}
export declare namespace SSEKMS {
    
    const filterSensitiveLog: (obj: SSEKMS) => any;
}

export interface SSES3 {
}
export declare namespace SSES3 {
    
    const filterSensitiveLog: (obj: SSES3) => any;
}

export interface InventoryEncryption {
    
    SSES3?: SSES3;
    
    SSEKMS?: SSEKMS;
}
export declare namespace InventoryEncryption {
    
    const filterSensitiveLog: (obj: InventoryEncryption) => any;
}
export declare type InventoryFormat = "CSV" | "ORC" | "Parquet";

export interface InventoryS3BucketDestination {
    
    AccountId?: string;
    
    Bucket: string | undefined;
    
    Format: InventoryFormat | string | undefined;
    
    Prefix?: string;
    
    Encryption?: InventoryEncryption;
}
export declare namespace InventoryS3BucketDestination {
    
    const filterSensitiveLog: (obj: InventoryS3BucketDestination) => any;
}

export interface InventoryDestination {
    
    S3BucketDestination: InventoryS3BucketDestination | undefined;
}
export declare namespace InventoryDestination {
    
    const filterSensitiveLog: (obj: InventoryDestination) => any;
}

export interface InventoryFilter {
    
    Prefix: string | undefined;
}
export declare namespace InventoryFilter {
    
    const filterSensitiveLog: (obj: InventoryFilter) => any;
}
export declare type InventoryIncludedObjectVersions = "All" | "Current";
export declare type InventoryOptionalField = "BucketKeyStatus" | "ChecksumAlgorithm" | "ETag" | "EncryptionStatus" | "IntelligentTieringAccessTier" | "IsMultipartUploaded" | "LastModifiedDate" | "ObjectLockLegalHoldStatus" | "ObjectLockMode" | "ObjectLockRetainUntilDate" | "ReplicationStatus" | "Size" | "StorageClass";
export declare type InventoryFrequency = "Daily" | "Weekly";

export interface InventorySchedule {
    
    Frequency: InventoryFrequency | string | undefined;
}
export declare namespace InventorySchedule {
    
    const filterSensitiveLog: (obj: InventorySchedule) => any;
}

export interface InventoryConfiguration {
    
    Destination: InventoryDestination | undefined;
    
    IsEnabled: boolean | undefined;
    
    Filter?: InventoryFilter;
    
    Id: string | undefined;
    
    IncludedObjectVersions: InventoryIncludedObjectVersions | string | undefined;
    
    OptionalFields?: (InventoryOptionalField | string)[];
    
    Schedule: InventorySchedule | undefined;
}
export declare namespace InventoryConfiguration {
    
    const filterSensitiveLog: (obj: InventoryConfiguration) => any;
}
export interface GetBucketInventoryConfigurationOutput {
    
    InventoryConfiguration?: InventoryConfiguration;
}
export declare namespace GetBucketInventoryConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketInventoryConfigurationOutput) => any;
}
export interface GetBucketInventoryConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketInventoryConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketInventoryConfigurationRequest) => any;
}

export interface LifecycleExpiration {
    
    Date?: Date;
    
    Days?: number;
    
    ExpiredObjectDeleteMarker?: boolean;
}
export declare namespace LifecycleExpiration {
    
    const filterSensitiveLog: (obj: LifecycleExpiration) => any;
}

export interface LifecycleRuleAndOperator {
    
    Prefix?: string;
    
    Tags?: Tag[];
    
    ObjectSizeGreaterThan?: number;
    
    ObjectSizeLessThan?: number;
}
export declare namespace LifecycleRuleAndOperator {
    
    const filterSensitiveLog: (obj: LifecycleRuleAndOperator) => any;
}

export declare type LifecycleRuleFilter = LifecycleRuleFilter.AndMember | LifecycleRuleFilter.ObjectSizeGreaterThanMember | LifecycleRuleFilter.ObjectSizeLessThanMember | LifecycleRuleFilter.PrefixMember | LifecycleRuleFilter.TagMember | LifecycleRuleFilter.$UnknownMember;
export declare namespace LifecycleRuleFilter {
    
    interface PrefixMember {
        Prefix: string;
        Tag?: never;
        ObjectSizeGreaterThan?: never;
        ObjectSizeLessThan?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface TagMember {
        Prefix?: never;
        Tag: Tag;
        ObjectSizeGreaterThan?: never;
        ObjectSizeLessThan?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface ObjectSizeGreaterThanMember {
        Prefix?: never;
        Tag?: never;
        ObjectSizeGreaterThan: number;
        ObjectSizeLessThan?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface ObjectSizeLessThanMember {
        Prefix?: never;
        Tag?: never;
        ObjectSizeGreaterThan?: never;
        ObjectSizeLessThan: number;
        And?: never;
        $unknown?: never;
    }
    
    interface AndMember {
        Prefix?: never;
        Tag?: never;
        ObjectSizeGreaterThan?: never;
        ObjectSizeLessThan?: never;
        And: LifecycleRuleAndOperator;
        $unknown?: never;
    }
    interface $UnknownMember {
        Prefix?: never;
        Tag?: never;
        ObjectSizeGreaterThan?: never;
        ObjectSizeLessThan?: never;
        And?: never;
        $unknown: [
            string,
            any
        ];
    }
    interface Visitor<T> {
        Prefix: (value: string) => T;
        Tag: (value: Tag) => T;
        ObjectSizeGreaterThan: (value: number) => T;
        ObjectSizeLessThan: (value: number) => T;
        And: (value: LifecycleRuleAndOperator) => T;
        _: (name: string, value: any) => T;
    }
    const visit: <T>(value: LifecycleRuleFilter, visitor: Visitor<T>) => T;
    
    const filterSensitiveLog: (obj: LifecycleRuleFilter) => any;
}

export interface NoncurrentVersionExpiration {
    
    NoncurrentDays?: number;
    
    NewerNoncurrentVersions?: number;
}
export declare namespace NoncurrentVersionExpiration {
    
    const filterSensitiveLog: (obj: NoncurrentVersionExpiration) => any;
}
export declare type TransitionStorageClass = "DEEP_ARCHIVE" | "GLACIER" | "GLACIER_IR" | "INTELLIGENT_TIERING" | "ONEZONE_IA" | "STANDARD_IA";

export interface NoncurrentVersionTransition {
    
    NoncurrentDays?: number;
    
    StorageClass?: TransitionStorageClass | string;
    
    NewerNoncurrentVersions?: number;
}
export declare namespace NoncurrentVersionTransition {
    
    const filterSensitiveLog: (obj: NoncurrentVersionTransition) => any;
}
export declare type ExpirationStatus = "Disabled" | "Enabled";

export interface Transition {
    
    Date?: Date;
    
    Days?: number;
    
    StorageClass?: TransitionStorageClass | string;
}
export declare namespace Transition {
    
    const filterSensitiveLog: (obj: Transition) => any;
}

export interface LifecycleRule {
    
    Expiration?: LifecycleExpiration;
    
    ID?: string;
    
    Prefix?: string;
    
    Filter?: LifecycleRuleFilter;
    
    Status: ExpirationStatus | string | undefined;
    
    Transitions?: Transition[];
    
    NoncurrentVersionTransitions?: NoncurrentVersionTransition[];
    
    NoncurrentVersionExpiration?: NoncurrentVersionExpiration;
    
    AbortIncompleteMultipartUpload?: AbortIncompleteMultipartUpload;
}
export declare namespace LifecycleRule {
    
    const filterSensitiveLog: (obj: LifecycleRule) => any;
}
export interface GetBucketLifecycleConfigurationOutput {
    
    Rules?: LifecycleRule[];
}
export declare namespace GetBucketLifecycleConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketLifecycleConfigurationOutput) => any;
}
export interface GetBucketLifecycleConfigurationRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketLifecycleConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketLifecycleConfigurationRequest) => any;
}
export interface GetBucketLocationOutput {
    
    LocationConstraint?: BucketLocationConstraint | string;
}
export declare namespace GetBucketLocationOutput {
    
    const filterSensitiveLog: (obj: GetBucketLocationOutput) => any;
}
export interface GetBucketLocationRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketLocationRequest {
    
    const filterSensitiveLog: (obj: GetBucketLocationRequest) => any;
}
export declare type BucketLogsPermission = "FULL_CONTROL" | "READ" | "WRITE";

export interface TargetGrant {
    
    Grantee?: Grantee;
    
    Permission?: BucketLogsPermission | string;
}
export declare namespace TargetGrant {
    
    const filterSensitiveLog: (obj: TargetGrant) => any;
}

export interface LoggingEnabled {
    
    TargetBucket: string | undefined;
    
    TargetGrants?: TargetGrant[];
    
    TargetPrefix: string | undefined;
}
export declare namespace LoggingEnabled {
    
    const filterSensitiveLog: (obj: LoggingEnabled) => any;
}
export interface GetBucketLoggingOutput {
    
    LoggingEnabled?: LoggingEnabled;
}
export declare namespace GetBucketLoggingOutput {
    
    const filterSensitiveLog: (obj: GetBucketLoggingOutput) => any;
}
export interface GetBucketLoggingRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketLoggingRequest {
    
    const filterSensitiveLog: (obj: GetBucketLoggingRequest) => any;
}

export interface MetricsAndOperator {
    
    Prefix?: string;
    
    Tags?: Tag[];
    
    AccessPointArn?: string;
}
export declare namespace MetricsAndOperator {
    
    const filterSensitiveLog: (obj: MetricsAndOperator) => any;
}

export declare type MetricsFilter = MetricsFilter.AccessPointArnMember | MetricsFilter.AndMember | MetricsFilter.PrefixMember | MetricsFilter.TagMember | MetricsFilter.$UnknownMember;
export declare namespace MetricsFilter {
    
    interface PrefixMember {
        Prefix: string;
        Tag?: never;
        AccessPointArn?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface TagMember {
        Prefix?: never;
        Tag: Tag;
        AccessPointArn?: never;
        And?: never;
        $unknown?: never;
    }
    
    interface AccessPointArnMember {
        Prefix?: never;
        Tag?: never;
        AccessPointArn: string;
        And?: never;
        $unknown?: never;
    }
    
    interface AndMember {
        Prefix?: never;
        Tag?: never;
        AccessPointArn?: never;
        And: MetricsAndOperator;
        $unknown?: never;
    }
    interface $UnknownMember {
        Prefix?: never;
        Tag?: never;
        AccessPointArn?: never;
        And?: never;
        $unknown: [
            string,
            any
        ];
    }
    interface Visitor<T> {
        Prefix: (value: string) => T;
        Tag: (value: Tag) => T;
        AccessPointArn: (value: string) => T;
        And: (value: MetricsAndOperator) => T;
        _: (name: string, value: any) => T;
    }
    const visit: <T>(value: MetricsFilter, visitor: Visitor<T>) => T;
    
    const filterSensitiveLog: (obj: MetricsFilter) => any;
}

export interface MetricsConfiguration {
    
    Id: string | undefined;
    
    Filter?: MetricsFilter;
}
export declare namespace MetricsConfiguration {
    
    const filterSensitiveLog: (obj: MetricsConfiguration) => any;
}
export interface GetBucketMetricsConfigurationOutput {
    
    MetricsConfiguration?: MetricsConfiguration;
}
export declare namespace GetBucketMetricsConfigurationOutput {
    
    const filterSensitiveLog: (obj: GetBucketMetricsConfigurationOutput) => any;
}
export interface GetBucketMetricsConfigurationRequest {
    
    Bucket: string | undefined;
    
    Id: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketMetricsConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketMetricsConfigurationRequest) => any;
}
export interface GetBucketNotificationConfigurationRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketNotificationConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetBucketNotificationConfigurationRequest) => any;
}

export interface EventBridgeConfiguration {
}
export declare namespace EventBridgeConfiguration {
    
    const filterSensitiveLog: (obj: EventBridgeConfiguration) => any;
}
export declare type Event = "s3:IntelligentTiering" | "s3:LifecycleExpiration:*" | "s3:LifecycleExpiration:Delete" | "s3:LifecycleExpiration:DeleteMarkerCreated" | "s3:LifecycleTransition" | "s3:ObjectAcl:Put" | "s3:ObjectCreated:*" | "s3:ObjectCreated:CompleteMultipartUpload" | "s3:ObjectCreated:Copy" | "s3:ObjectCreated:Post" | "s3:ObjectCreated:Put" | "s3:ObjectRemoved:*" | "s3:ObjectRemoved:Delete" | "s3:ObjectRemoved:DeleteMarkerCreated" | "s3:ObjectRestore:*" | "s3:ObjectRestore:Completed" | "s3:ObjectRestore:Delete" | "s3:ObjectRestore:Post" | "s3:ObjectTagging:*" | "s3:ObjectTagging:Delete" | "s3:ObjectTagging:Put" | "s3:ReducedRedundancyLostObject" | "s3:Replication:*" | "s3:Replication:OperationFailedReplication" | "s3:Replication:OperationMissedThreshold" | "s3:Replication:OperationNotTracked" | "s3:Replication:OperationReplicatedAfterThreshold";
export declare type FilterRuleName = "prefix" | "suffix";

export interface FilterRule {
    
    Name?: FilterRuleName | string;
    
    Value?: string;
}
export declare namespace FilterRule {
    
    const filterSensitiveLog: (obj: FilterRule) => any;
}

export interface S3KeyFilter {
    
    FilterRules?: FilterRule[];
}
export declare namespace S3KeyFilter {
    
    const filterSensitiveLog: (obj: S3KeyFilter) => any;
}

export interface NotificationConfigurationFilter {
    
    Key?: S3KeyFilter;
}
export declare namespace NotificationConfigurationFilter {
    
    const filterSensitiveLog: (obj: NotificationConfigurationFilter) => any;
}

export interface LambdaFunctionConfiguration {
    
    Id?: string;
    
    LambdaFunctionArn: string | undefined;
    
    Events: (Event | string)[] | undefined;
    
    Filter?: NotificationConfigurationFilter;
}
export declare namespace LambdaFunctionConfiguration {
    
    const filterSensitiveLog: (obj: LambdaFunctionConfiguration) => any;
}

export interface QueueConfiguration {
    
    Id?: string;
    
    QueueArn: string | undefined;
    
    Events: (Event | string)[] | undefined;
    
    Filter?: NotificationConfigurationFilter;
}
export declare namespace QueueConfiguration {
    
    const filterSensitiveLog: (obj: QueueConfiguration) => any;
}

export interface TopicConfiguration {
    
    Id?: string;
    
    TopicArn: string | undefined;
    
    Events: (Event | string)[] | undefined;
    
    Filter?: NotificationConfigurationFilter;
}
export declare namespace TopicConfiguration {
    
    const filterSensitiveLog: (obj: TopicConfiguration) => any;
}

export interface NotificationConfiguration {
    
    TopicConfigurations?: TopicConfiguration[];
    
    QueueConfigurations?: QueueConfiguration[];
    
    LambdaFunctionConfigurations?: LambdaFunctionConfiguration[];
    
    EventBridgeConfiguration?: EventBridgeConfiguration;
}
export declare namespace NotificationConfiguration {
    
    const filterSensitiveLog: (obj: NotificationConfiguration) => any;
}

export interface OwnershipControlsRule {
    
    ObjectOwnership: ObjectOwnership | string | undefined;
}
export declare namespace OwnershipControlsRule {
    
    const filterSensitiveLog: (obj: OwnershipControlsRule) => any;
}

export interface OwnershipControls {
    
    Rules: OwnershipControlsRule[] | undefined;
}
export declare namespace OwnershipControls {
    
    const filterSensitiveLog: (obj: OwnershipControls) => any;
}
export interface GetBucketOwnershipControlsOutput {
    
    OwnershipControls?: OwnershipControls;
}
export declare namespace GetBucketOwnershipControlsOutput {
    
    const filterSensitiveLog: (obj: GetBucketOwnershipControlsOutput) => any;
}
export interface GetBucketOwnershipControlsRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketOwnershipControlsRequest {
    
    const filterSensitiveLog: (obj: GetBucketOwnershipControlsRequest) => any;
}
export interface GetBucketPolicyOutput {
    
    Policy?: string;
}
export declare namespace GetBucketPolicyOutput {
    
    const filterSensitiveLog: (obj: GetBucketPolicyOutput) => any;
}
export interface GetBucketPolicyRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketPolicyRequest {
    
    const filterSensitiveLog: (obj: GetBucketPolicyRequest) => any;
}

export interface PolicyStatus {
    
    IsPublic?: boolean;
}
export declare namespace PolicyStatus {
    
    const filterSensitiveLog: (obj: PolicyStatus) => any;
}
export interface GetBucketPolicyStatusOutput {
    
    PolicyStatus?: PolicyStatus;
}
export declare namespace GetBucketPolicyStatusOutput {
    
    const filterSensitiveLog: (obj: GetBucketPolicyStatusOutput) => any;
}
export interface GetBucketPolicyStatusRequest {
    
    Bucket: string | undefined;
    
    ExpectedBucketOwner?: string;
}
export declare namespace GetBucketPolicyStatusRequest {
    
    const filterSensitiveLog: (obj: GetBucketPolicyStatusRequest) => any;
}
export declare type DeleteMarkerReplicationStatus = "Disabled" | "Enabled";

export interface DeleteMarkerReplication {
    
    Status?: DeleteMarkerReplicationStatus | string;
}
export declare namespace DeleteMarkerReplication {
    
    const filterSensitiveLog: (obj: DeleteMarkerReplication) => any;
}

export interface EncryptionConfiguration {
    
    ReplicaKmsKeyID?: string;
}
export declare namespace EncryptionConfiguration {
    
    const filterSensitiveLog: (obj: EncryptionConfiguration) => any;
}

export interface ReplicationTimeValue {
    
    Minutes?: number;
}
export declare namespace ReplicationTimeValue {
    
    const filterSensitiveLog: (obj: ReplicationTimeValue) => any;
}
export declare type MetricsStatus = "Disabled" | "Enabled";

export interface Metrics {
    
    Status: MetricsStatus | string | undefined;
    
    EventThreshold?: ReplicationTimeValue;
}
export declare namespace Metrics {
    
    const filterSensitiveLog: (obj: Metrics) => any;
}
export declare type ReplicationTimeStatus = "Disabled" | "Enabled";

export interface ReplicationTime {
    
    Status: ReplicationTimeStatus | string | undefined;
    
    Time: ReplicationTimeValue | undefined;
}
export declare namespace ReplicationTime {
    
    const filterSensitiveLog: (obj: ReplicationTime) => any;
}

export interface Destination {
    
    Bucket: string | undefined;
    
    Account?: string;
    
    StorageClass?: StorageClass | string;
    
    AccessControlTranslation?: AccessControlTranslation;
    
    EncryptionConfiguration?: EncryptionConfiguration;
    
    ReplicationTime?: ReplicationTime;
    
    Metrics?: Metrics;
}
export declare namespace Destination {
    
    const filterSensitiveLog: (obj: Destination) => any;
}
export declare type ExistingObjectReplicationStatus = "Disabled" | "Enabled";

export interface ExistingObjectReplication {
    
    Status: ExistingObjectReplicationStatus | string | undefined;
}
export declare namespace ExistingObjectReplication {
    
    const filterSensitiveLog: (obj: ExistingObjectReplication) => any;
}

export interface ReplicationRuleAndOperator {
    
    Prefix?: string;
    
    Tags?: Tag[];
}
export declare namespace ReplicationRuleAndOperator {
    
    const filterSensitiveLo