@aws-sdk/client-s3 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_1.d.ts

@@ -0,0 +1,767 @@
+
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { Readable } from "stream";
+import { ChecksumAlgorithm, Grant, ObjectCannedACL, ObjectLockLegalHoldStatus, ObjectLockMode, ObjectLockRetention, PublicAccessBlockConfiguration, ReplicationStatus, RequestCharged, RequestPayer, ServerSideEncryption, StorageClass, Tagging } from "./models_0";
+import { S3ServiceException as __BaseException } from "./S3ServiceException";
+export interface PutObjectRetentionOutput {
+    
+    RequestCharged?: RequestCharged | string;
+}
+export declare namespace PutObjectRetentionOutput {
+    
+    const filterSensitiveLog: (obj: PutObjectRetentionOutput) => any;
+}
+export interface PutObjectRetentionRequest {
+    
+    Bucket: string | undefined;
+    
+    Key: string | undefined;
+    
+    Retention?: ObjectLockRetention;
+    
+    RequestPayer?: RequestPayer | string;
+    
+    VersionId?: string;
+    
+    BypassGovernanceRetention?: boolean;
+    
+    ContentMD5?: string;
+    
+    ChecksumAlgorithm?: ChecksumAlgorithm | string;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace PutObjectRetentionRequest {
+    
+    const filterSensitiveLog: (obj: PutObjectRetentionRequest) => any;
+}
+export interface PutObjectTaggingOutput {
+    
+    VersionId?: string;
+}
+export declare namespace PutObjectTaggingOutput {
+    
+    const filterSensitiveLog: (obj: PutObjectTaggingOutput) => any;
+}
+export interface PutObjectTaggingRequest {
+    
+    Bucket: string | undefined;
+    
+    Key: string | undefined;
+    
+    VersionId?: string;
+    
+    ContentMD5?: string;
+    
+    ChecksumAlgorithm?: ChecksumAlgorithm | string;
+    
+    Tagging: Tagging | undefined;
+    
+    ExpectedBucketOwner?: string;
+    
+    RequestPayer?: RequestPayer | string;
+}
+export declare namespace PutObjectTaggingRequest {
+    
+    const filterSensitiveLog: (obj: PutObjectTaggingRequest) => any;
+}
+export interface PutPublicAccessBlockRequest {
+    
+    Bucket: string | undefined;
+    
+    ContentMD5?: string;
+    
+    ChecksumAlgorithm?: ChecksumAlgorithm | string;
+    
+    PublicAccessBlockConfiguration: PublicAccessBlockConfiguration | undefined;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace PutPublicAccessBlockRequest {
+    
+    const filterSensitiveLog: (obj: PutPublicAccessBlockRequest) => any;
+}
+
+export declare class ObjectAlreadyInActiveTierError extends __BaseException {
+    readonly name: "ObjectAlreadyInActiveTierError";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ObjectAlreadyInActiveTierError, __BaseException>);
+}
+export interface RestoreObjectOutput {
+    
+    RequestCharged?: RequestCharged | string;
+    
+    RestoreOutputPath?: string;
+}
+export declare namespace RestoreObjectOutput {
+    
+    const filterSensitiveLog: (obj: RestoreObjectOutput) => any;
+}
+export declare type Tier = "Bulk" | "Expedited" | "Standard";
+
+export interface GlacierJobParameters {
+    
+    Tier: Tier | string | undefined;
+}
+export declare namespace GlacierJobParameters {
+    
+    const filterSensitiveLog: (obj: GlacierJobParameters) => any;
+}
+
+export interface Encryption {
+    
+    EncryptionType: ServerSideEncryption | string | undefined;
+    
+    KMSKeyId?: string;
+    
+    KMSContext?: string;
+}
+export declare namespace Encryption {
+    
+    const filterSensitiveLog: (obj: Encryption) => any;
+}
+
+export interface MetadataEntry {
+    
+    Name?: string;
+    
+    Value?: string;
+}
+export declare namespace MetadataEntry {
+    
+    const filterSensitiveLog: (obj: MetadataEntry) => any;
+}
+
+export interface S3Location {
+    
+    BucketName: string | undefined;
+    
+    Prefix: string | undefined;
+    
+    Encryption?: Encryption;
+    
+    CannedACL?: ObjectCannedACL | string;
+    
+    AccessControlList?: Grant[];
+    
+    Tagging?: Tagging;
+    
+    UserMetadata?: MetadataEntry[];
+    
+    StorageClass?: StorageClass | string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+
+export interface OutputLocation {
+    
+    S3?: S3Location;
+}
+export declare namespace OutputLocation {
+    
+    const filterSensitiveLog: (obj: OutputLocation) => any;
+}
+export declare type ExpressionType = "SQL";
+export declare type CompressionType = "BZIP2" | "GZIP" | "NONE";
+export declare enum FileHeaderInfo {
+    IGNORE = "IGNORE",
+    NONE = "NONE",
+    USE = "USE"
+}
+
+export interface CSVInput {
+    
+    FileHeaderInfo?: FileHeaderInfo | string;
+    
+    Comments?: string;
+    
+    QuoteEscapeCharacter?: string;
+    
+    RecordDelimiter?: string;
+    
+    FieldDelimiter?: string;
+    
+    QuoteCharacter?: string;
+    
+    AllowQuotedRecordDelimiter?: boolean;
+}
+export declare namespace CSVInput {
+    
+    const filterSensitiveLog: (obj: CSVInput) => any;
+}
+export declare enum JSONType {
+    DOCUMENT = "DOCUMENT",
+    LINES = "LINES"
+}
+
+export interface JSONInput {
+    
+    Type?: JSONType | string;
+}
+export declare namespace JSONInput {
+    
+    const filterSensitiveLog: (obj: JSONInput) => any;
+}
+
+export interface ParquetInput {
+}
+export declare namespace ParquetInput {
+    
+    const filterSensitiveLog: (obj: ParquetInput) => any;
+}
+
+export interface InputSerialization {
+    
+    CSV?: CSVInput;
+    
+    CompressionType?: CompressionType | string;
+    
+    JSON?: JSONInput;
+    
+    Parquet?: ParquetInput;
+}
+export declare namespace InputSerialization {
+    
+    const filterSensitiveLog: (obj: InputSerialization) => any;
+}
+export declare enum QuoteFields {
+    ALWAYS = "ALWAYS",
+    ASNEEDED = "ASNEEDED"
+}
+
+export interface CSVOutput {
+    
+    QuoteFields?: QuoteFields | string;
+    
+    QuoteEscapeCharacter?: string;
+    
+    RecordDelimiter?: string;
+    
+    FieldDelimiter?: string;
+    
+    QuoteCharacter?: string;
+}
+export declare namespace CSVOutput {
+    
+    const filterSensitiveLog: (obj: CSVOutput) => any;
+}
+
+export interface JSONOutput {
+    
+    RecordDelimiter?: string;
+}
+export declare namespace JSONOutput {
+    
+    const filterSensitiveLog: (obj: JSONOutput) => any;
+}
+
+export interface OutputSerialization {
+    
+    CSV?: CSVOutput;
+    
+    JSON?: JSONOutput;
+}
+export declare namespace OutputSerialization {
+    
+    const filterSensitiveLog: (obj: OutputSerialization) => any;
+}
+
+export interface SelectParameters {
+    
+    InputSerialization: InputSerialization | undefined;
+    
+    ExpressionType: ExpressionType | string | undefined;
+    
+    Expression: string | undefined;
+    
+    OutputSerialization: OutputSerialization | undefined;
+}
+export declare namespace SelectParameters {
+    
+    const filterSensitiveLog: (obj: SelectParameters) => any;
+}
+export declare enum RestoreRequestType {
+    SELECT = "SELECT"
+}
+
+export interface RestoreRequest {
+    
+    Days?: number;
+    
+    GlacierJobParameters?: GlacierJobParameters;
+    
+    Type?: RestoreRequestType | string;
+    
+    Tier?: Tier | string;
+    
+    Description?: string;
+    
+    SelectParameters?: SelectParameters;
+    
+    OutputLocation?: OutputLocation;
+}
+export declare namespace RestoreRequest {
+    
+    const filterSensitiveLog: (obj: RestoreRequest) => any;
+}
+export interface RestoreObjectRequest {
+    
+    Bucket: string | undefined;
+    
+    Key: string | undefined;
+    
+    VersionId?: string;
+    
+    RestoreRequest?: RestoreRequest;
+    
+    RequestPayer?: RequestPayer | string;
+    
+    ChecksumAlgorithm?: ChecksumAlgorithm | string;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace RestoreObjectRequest {
+    
+    const filterSensitiveLog: (obj: RestoreObjectRequest) => any;
+}
+
+export interface ContinuationEvent {
+}
+export declare namespace ContinuationEvent {
+    
+    const filterSensitiveLog: (obj: ContinuationEvent) => any;
+}
+
+export interface EndEvent {
+}
+export declare namespace EndEvent {
+    
+    const filterSensitiveLog: (obj: EndEvent) => any;
+}
+
+export interface Progress {
+    
+    BytesScanned?: number;
+    
+    BytesProcessed?: number;
+    
+    BytesReturned?: number;
+}
+export declare namespace Progress {
+    
+    const filterSensitiveLog: (obj: Progress) => any;
+}
+
+export interface ProgressEvent {
+    
+    Details?: Progress;
+}
+export declare namespace ProgressEvent {
+    
+    const filterSensitiveLog: (obj: ProgressEvent) => any;
+}
+
+export interface RecordsEvent {
+    
+    Payload?: Uint8Array;
+}
+export declare namespace RecordsEvent {
+    
+    const filterSensitiveLog: (obj: RecordsEvent) => any;
+}
+
+export interface Stats {
+    
+    BytesScanned?: number;
+    
+    BytesProcessed?: number;
+    
+    BytesReturned?: number;
+}
+export declare namespace Stats {
+    
+    const filterSensitiveLog: (obj: Stats) => any;
+}
+
+export interface StatsEvent {
+    
+    Details?: Stats;
+}
+export declare namespace StatsEvent {
+    
+    const filterSensitiveLog: (obj: StatsEvent) => any;
+}
+
+export declare type SelectObjectContentEventStream = SelectObjectContentEventStream.ContMember | SelectObjectContentEventStream.EndMember | SelectObjectContentEventStream.ProgressMember | SelectObjectContentEventStream.RecordsMember | SelectObjectContentEventStream.StatsMember | SelectObjectContentEventStream.$UnknownMember;
+export declare namespace SelectObjectContentEventStream {
+    
+    interface RecordsMember {
+        Records: RecordsEvent;
+        Stats?: never;
+        Progress?: never;
+        Cont?: never;
+        End?: never;
+        $unknown?: never;
+    }
+    
+    interface StatsMember {
+        Records?: never;
+        Stats: StatsEvent;
+        Progress?: never;
+        Cont?: never;
+        End?: never;
+        $unknown?: never;
+    }
+    
+    interface ProgressMember {
+        Records?: never;
+        Stats?: never;
+        Progress: ProgressEvent;
+        Cont?: never;
+        End?: never;
+        $unknown?: never;
+    }
+    
+    interface ContMember {
+        Records?: never;
+        Stats?: never;
+        Progress?: never;
+        Cont: ContinuationEvent;
+        End?: never;
+        $unknown?: never;
+    }
+    
+    interface EndMember {
+        Records?: never;
+        Stats?: never;
+        Progress?: never;
+        Cont?: never;
+        End: EndEvent;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        Records?: never;
+        Stats?: never;
+        Progress?: never;
+        Cont?: never;
+        End?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        Records: (value: RecordsEvent) => T;
+        Stats: (value: StatsEvent) => T;
+        Progress: (value: ProgressEvent) => T;
+        Cont: (value: ContinuationEvent) => T;
+        End: (value: EndEvent) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: SelectObjectContentEventStream, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: SelectObjectContentEventStream) => any;
+}
+export interface SelectObjectContentOutput {
+    
+    Payload?: AsyncIterable<SelectObjectContentEventStream>;
+}
+export declare namespace SelectObjectContentOutput {
+    
+    const filterSensitiveLog: (obj: SelectObjectContentOutput) => any;
+}
+
+export interface RequestProgress {
+    
+    Enabled?: boolean;
+}
+export declare namespace RequestProgress {
+    
+    const filterSensitiveLog: (obj: RequestProgress) => any;
+}
+
+export interface ScanRange {
+    
+    Start?: number;
+    
+    End?: number;
+}
+export declare namespace ScanRange {
+    
+    const filterSensitiveLog: (obj: ScanRange) => any;
+}
+
+export interface SelectObjectContentRequest {
+    
+    Bucket: string | undefined;
+    
+    Key: string | undefined;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSECustomerKey?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    Expression: string | undefined;
+    
+    ExpressionType: ExpressionType | string | undefined;
+    
+    RequestProgress?: RequestProgress;
+    
+    InputSerialization: InputSerialization | undefined;
+    
+    OutputSerialization: OutputSerialization | undefined;
+    
+    ScanRange?: ScanRange;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace SelectObjectContentRequest {
+    
+    const filterSensitiveLog: (obj: SelectObjectContentRequest) => any;
+}
+export interface UploadPartOutput {
+    
+    ServerSideEncryption?: ServerSideEncryption | string;
+    
+    ETag?: string;
+    
+    ChecksumCRC32?: string;
+    
+    ChecksumCRC32C?: string;
+    
+    ChecksumSHA1?: string;
+    
+    ChecksumSHA256?: string;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    SSEKMSKeyId?: string;
+    
+    BucketKeyEnabled?: boolean;
+    
+    RequestCharged?: RequestCharged | string;
+}
+export declare namespace UploadPartOutput {
+    
+    const filterSensitiveLog: (obj: UploadPartOutput) => any;
+}
+export interface UploadPartRequest {
+    
+    Body?: Readable | ReadableStream | Blob;
+    
+    Bucket: string | undefined;
+    
+    ContentLength?: number;
+    
+    ContentMD5?: string;
+    
+    ChecksumAlgorithm?: ChecksumAlgorithm | string;
+    
+    ChecksumCRC32?: string;
+    
+    ChecksumCRC32C?: string;
+    
+    ChecksumSHA1?: string;
+    
+    ChecksumSHA256?: string;
+    
+    Key: string | undefined;
+    
+    PartNumber: number | undefined;
+    
+    UploadId: string | undefined;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSECustomerKey?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    RequestPayer?: RequestPayer | string;
+    
+    ExpectedBucketOwner?: string;
+}
+export declare namespace UploadPartRequest {
+    
+    const filterSensitiveLog: (obj: UploadPartRequest) => any;
+}
+
+export interface CopyPartResult {
+    
+    ETag?: string;
+    
+    LastModified?: Date;
+    
+    ChecksumCRC32?: string;
+    
+    ChecksumCRC32C?: string;
+    
+    ChecksumSHA1?: string;
+    
+    ChecksumSHA256?: string;
+}
+export declare namespace CopyPartResult {
+    
+    const filterSensitiveLog: (obj: CopyPartResult) => any;
+}
+export interface UploadPartCopyOutput {
+    
+    CopySourceVersionId?: string;
+    
+    CopyPartResult?: CopyPartResult;
+    
+    ServerSideEncryption?: ServerSideEncryption | string;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    SSEKMSKeyId?: string;
+    
+    BucketKeyEnabled?: boolean;
+    
+    RequestCharged?: RequestCharged | string;
+}
+export declare namespace UploadPartCopyOutput {
+    
+    const filterSensitiveLog: (obj: UploadPartCopyOutput) => any;
+}
+export interface UploadPartCopyRequest {
+    
+    Bucket: string | undefined;
+    
+    CopySource: string | undefined;
+    
+    CopySourceIfMatch?: string;
+    
+    CopySourceIfModifiedSince?: Date;
+    
+    CopySourceIfNoneMatch?: string;
+    
+    CopySourceIfUnmodifiedSince?: Date;
+    
+    CopySourceRange?: string;
+    
+    Key: string | undefined;
+    
+    PartNumber: number | undefined;
+    
+    UploadId: string | undefined;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSECustomerKey?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    CopySourceSSECustomerAlgorithm?: string;
+    
+    CopySourceSSECustomerKey?: string;
+    
+    CopySourceSSECustomerKeyMD5?: string;
+    
+    RequestPayer?: RequestPayer | string;
+    
+    ExpectedBucketOwner?: string;
+    
+    ExpectedSourceBucketOwner?: string;
+}
+export declare namespace UploadPartCopyRequest {
+    
+    const filterSensitiveLog: (obj: UploadPartCopyRequest) => any;
+}
+export interface WriteGetObjectResponseRequest {
+    
+    RequestRoute: string | undefined;
+    
+    RequestToken: string | undefined;
+    
+    Body?: Readable | ReadableStream | Blob;
+    
+    StatusCode?: number;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    AcceptRanges?: string;
+    
+    CacheControl?: string;
+    
+    ContentDisposition?: string;
+    
+    ContentEncoding?: string;
+    
+    ContentLanguage?: string;
+    
+    ContentLength?: number;
+    
+    ContentRange?: string;
+    
+    ContentType?: string;
+    
+    ChecksumCRC32?: string;
+    
+    ChecksumCRC32C?: string;
+    
+    ChecksumSHA1?: string;
+    
+    ChecksumSHA256?: string;
+    
+    DeleteMarker?: boolean;
+    
+    ETag?: string;
+    
+    Expires?: Date;
+    
+    Expiration?: string;
+    
+    LastModified?: Date;
+    
+    MissingMeta?: number;
+    
+    Metadata?: {
+        [key: string]: string;
+    };
+    
+    ObjectLockMode?: ObjectLockMode | string;
+    
+    ObjectLockLegalHoldStatus?: ObjectLockLegalHoldStatus | string;
+    
+    ObjectLockRetainUntilDate?: Date;
+    
+    PartsCount?: number;
+    
+    ReplicationStatus?: ReplicationStatus | string;
+    
+    RequestCharged?: RequestCharged | string;
+    
+    Restore?: string;
+    
+    ServerSideEncryption?: ServerSideEncryption | string;
+    
+    SSECustomerAlgorithm?: string;
+    
+    SSEKMSKeyId?: string;
+    
+    SSECustomerKeyMD5?: string;
+    
+    StorageClass?: StorageClass | string;
+    
+    TagCount?: number;
+    
+    VersionId?: string;
+    
+    BucketKeyEnabled?: boolean;
+}
+export declare namespace WriteGetObjectResponseRequest {
+    
+    const filterSensitiveLog: (obj: WriteGetObjectResponseRequest) => any;
+}