@aws-sdk/types

  • Version 3.78.0
  • Published
  • 164 kB
  • No dependencies
  • Apache-2.0 license

Install

npm i @aws-sdk/types
yarn add @aws-sdk/types
pnpm add @aws-sdk/types

Overview

Types for the AWS SDK

Index

Interfaces

Type Aliases

Interfaces

interface AbortController

interface AbortController {}
  • The AWS SDK uses a Controller/Signal model to allow for cooperative cancellation of asynchronous operations. When initiating such an operation, the caller can create an AbortController and then provide linked signal to subtasks. This allows a single source to communicate to multiple consumers that an action has been aborted without dictating how that cancellation should be handled.

    See Also

    • https://developer.mozilla.org/en-US/docs/Web/API/AbortController

property signal

readonly signal: AbortSignal;
  • An object that reports whether the action associated with this {AbortController} has been cancelled.

method abort

abort: () => void;
  • Declares the operation associated with this AbortController to have been cancelled.

interface AbortHandler

interface AbortHandler {}

    call signature

    (this: AbortSignal, ev: any): any;

      interface AbortSignal

      interface AbortSignal {}
      • Holders of an AbortSignal object may query if the associated operation has been aborted and register an onabort handler.

        See Also

        • https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal

      property aborted

      readonly aborted: boolean;
      • Whether the action represented by this signal has been cancelled.

      property onabort

      onabort: AbortHandler | null;
      • A function to be invoked when the action represented by this signal has been cancelled.

      interface AbsoluteLocation

      interface AbsoluteLocation {}

        property priority

        priority?: Priority;
        • By default middleware will be added to individual step in un-guaranteed order. In the case that

          'normal'

        interface BinaryHeaderValue

        interface BinaryHeaderValue {}

          property type

          type: 'binary';

            property value

            value: Uint8Array;

              interface BodyLengthCalculator

              interface BodyLengthCalculator {}
              • A function that, given a request body, determines the length of the body. This is used to determine the Content-Length that should be sent with a request.

                Example 1

                A function that reads a file stream and calculates the size of the file.

              call signature

              (body: any): number | undefined;

                interface BooleanHeaderValue

                interface BooleanHeaderValue {}

                  property type

                  type: 'boolean';

                    property value

                    value: boolean;

                      interface BuildHandler

                      interface BuildHandler<Input extends object, Output extends object> {}

                        call signature

                        (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;

                          interface BuildHandlerArguments

                          interface BuildHandlerArguments<Input extends object>
                          extends FinalizeHandlerArguments<Input> {}

                            interface BuildHandlerOptions

                            interface BuildHandlerOptions extends HandlerOptions {}

                              property step

                              step: 'build';

                                interface BuildHandlerOutput

                                interface BuildHandlerOutput<Output extends object>
                                extends InitializeHandlerOutput<Output> {}

                                  interface BuildMiddleware

                                  interface BuildMiddleware<Input extends object, Output extends object> {}

                                    call signature

                                    (
                                    next: BuildHandler<Input, Output>,
                                    context: HandlerExecutionContext
                                    ): BuildHandler<Input, Output>;

                                      interface ByteHeaderValue

                                      interface ByteHeaderValue {}

                                        property type

                                        type: 'byte';

                                          property value

                                          value: number;

                                            interface Client

                                            interface Client<
                                            Input extends object,
                                            Output extends MetadataBearer,
                                            ResolvedClientConfiguration
                                            > {}
                                            • A general interface for service clients, idempotent to browser or node clients This type corresponds to SmithyClient(https://github.com/aws/aws-sdk-js-v3/blob/main/packages/smithy-client/src/client.ts). It's provided for using without importing the SmithyClient class.

                                            property config

                                            readonly config: ResolvedClientConfiguration;

                                              property destroy

                                              destroy: () => void;

                                                property middlewareStack

                                                middlewareStack: MiddlewareStack<Input, Output>;

                                                  property send

                                                  send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;

                                                    interface Command

                                                    interface Command<
                                                    ClientInput extends object,
                                                    InputType extends ClientInput,
                                                    ClientOutput extends MetadataBearer,
                                                    OutputType extends ClientOutput,
                                                    ResolvedConfiguration
                                                    > {}

                                                      property input

                                                      readonly input: InputType;

                                                        property middlewareStack

                                                        readonly middlewareStack: MiddlewareStack<InputType, OutputType>;

                                                          method resolveMiddleware

                                                          resolveMiddleware: (
                                                          stack: MiddlewareStack<ClientInput, ClientOutput>,
                                                          configuration: ResolvedConfiguration,
                                                          options: any
                                                          ) => Handler<InputType, OutputType>;

                                                            interface Credentials

                                                            interface Credentials {}
                                                            • An object representing temporary or permanent AWS credentials.

                                                            property accessKeyId

                                                            readonly accessKeyId: string;
                                                            • AWS access key ID

                                                            property expiration

                                                            readonly expiration?: Date;
                                                            • A {Date} when these credentials will no longer be accepted.

                                                            property secretAccessKey

                                                            readonly secretAccessKey: string;
                                                            • AWS secret access key

                                                            property sessionToken

                                                            readonly sessionToken?: string;
                                                            • A security or session token to use with these credentials. Usually present for temporary credentials.

                                                            interface Decoder

                                                            interface Decoder {}
                                                            • A function that, given a string, can derive the bytes represented by that string.

                                                              Example 1

                                                              A decoder function that converts bytes to hexadecimal representation would return new Uint8Array([0xde, 0xad, 0xbe, 0xef]) when given the string 'deadbeef'.

                                                            call signature

                                                            (input: string): Uint8Array;

                                                              interface DeserializeHandler

                                                              interface DeserializeHandler<Input extends object, Output extends object> {}

                                                                call signature

                                                                (args: DeserializeHandlerArguments<Input>): Promise<
                                                                DeserializeHandlerOutput<Output>
                                                                >;

                                                                  interface DeserializeHandlerArguments

                                                                  interface DeserializeHandlerArguments<Input extends object>
                                                                  extends FinalizeHandlerArguments<Input> {}

                                                                    interface DeserializeHandlerOptions

                                                                    interface DeserializeHandlerOptions extends HandlerOptions {}

                                                                      property step

                                                                      step: 'deserialize';

                                                                        interface DeserializeHandlerOutput

                                                                        interface DeserializeHandlerOutput<Output extends object> {}

                                                                          property output

                                                                          output?: Output;

                                                                            property response

                                                                            response: unknown;
                                                                            • The raw response object from runtime is deserialized to structured output object. The response object is unknown so you cannot modify it directly. When work with response, you need to guard its type to e.g. HttpResponse with 'instanceof' operand.

                                                                              During the deserialize phase of the execution of a middleware stack, a deserialized response may or may not be available

                                                                            interface DeserializeMiddleware

                                                                            interface DeserializeMiddleware<Input extends object, Output extends object> {}

                                                                              call signature

                                                                              (
                                                                              next: DeserializeHandler<Input, Output>,
                                                                              context: HandlerExecutionContext
                                                                              ): DeserializeHandler<Input, Output>;

                                                                                interface Encoder

                                                                                interface Encoder {}
                                                                                • A function that, given a TypedArray of bytes, can produce a string representation thereof.

                                                                                  Example 1

                                                                                  An encoder function that converts bytes to hexadecimal representation would return 'deadbeef' when given `new Uint8Array([0xde, 0xad, 0xbe, 0xef])`.

                                                                                call signature

                                                                                (input: Uint8Array): string;

                                                                                  interface Endpoint

                                                                                  interface Endpoint {}

                                                                                    property hostname

                                                                                    hostname: string;

                                                                                      property path

                                                                                      path: string;

                                                                                        property port

                                                                                        port?: number;

                                                                                          property protocol

                                                                                          protocol: string;

                                                                                            property query

                                                                                            query?: QueryParameterBag;

                                                                                              interface EndpointBearer

                                                                                              interface EndpointBearer {}
                                                                                              • Interface for object requires an Endpoint set.

                                                                                              property endpoint

                                                                                              endpoint: Provider<Endpoint>;

                                                                                                interface EventSigner

                                                                                                interface EventSigner {}

                                                                                                  method sign

                                                                                                  sign: (event: FormattedEvent, options: EventSigningArguments) => Promise<string>;
                                                                                                  • Sign the individual event of the event stream.

                                                                                                  interface EventSigningArguments

                                                                                                  interface EventSigningArguments extends SigningArguments {}

                                                                                                    property priorSignature

                                                                                                    priorSignature: string;

                                                                                                      interface EventStreamMarshaller

                                                                                                      interface EventStreamMarshaller {}

                                                                                                        property deserialize

                                                                                                        deserialize: (
                                                                                                        body: any,
                                                                                                        deserializer: (input: { [event: string]: Message }) => any
                                                                                                        ) => AsyncIterable<any>;

                                                                                                          property serialize

                                                                                                          serialize: (
                                                                                                          input: AsyncIterable<any>,
                                                                                                          serializer: (event: any) => Message
                                                                                                          ) => any;

                                                                                                            interface EventStreamPayloadHandler

                                                                                                            interface EventStreamPayloadHandler {}

                                                                                                              property handle

                                                                                                              handle: <Input extends object, Output extends MetadataBearer>(
                                                                                                              next: FinalizeHandler<Input, Output>,
                                                                                                              args: FinalizeHandlerArguments<Input>,
                                                                                                              context?: HandlerExecutionContext
                                                                                                              ) => Promise<FinalizeHandlerOutput<Output>>;

                                                                                                                interface EventStreamPayloadHandlerProvider

                                                                                                                interface EventStreamPayloadHandlerProvider {}

                                                                                                                  call signature

                                                                                                                  (options: any): EventStreamPayloadHandler;

                                                                                                                    interface EventStreamRequestSigner

                                                                                                                    interface EventStreamRequestSigner {}

                                                                                                                      method sign

                                                                                                                      sign: (request: HttpRequest) => Promise<HttpRequest>;

                                                                                                                        interface EventStreamSerdeContext

                                                                                                                        interface EventStreamSerdeContext {}
                                                                                                                        • Util functions for serializing or deserializing event stream

                                                                                                                        property eventStreamMarshaller

                                                                                                                        eventStreamMarshaller: EventStreamMarshaller;

                                                                                                                          interface EventStreamSerdeProvider

                                                                                                                          interface EventStreamSerdeProvider {}

                                                                                                                            call signature

                                                                                                                            (options: any): EventStreamMarshaller;

                                                                                                                              interface EventStreamSignerProvider

                                                                                                                              interface EventStreamSignerProvider {}

                                                                                                                                call signature

                                                                                                                                (options: any): EventStreamRequestSigner;

                                                                                                                                  interface FinalizeHandler

                                                                                                                                  interface FinalizeHandler<Input extends object, Output extends object> {}

                                                                                                                                    call signature

                                                                                                                                    (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>>;
                                                                                                                                    • Asynchronously converts an input object into an output object.

                                                                                                                                      Parameter args

                                                                                                                                      An object containing a input to the command as well as any associated or previously generated execution artifacts.

                                                                                                                                    interface FinalizeHandlerArguments

                                                                                                                                    interface FinalizeHandlerArguments<Input extends object>
                                                                                                                                    extends SerializeHandlerArguments<Input> {}

                                                                                                                                      property request

                                                                                                                                      request: unknown;
                                                                                                                                      • The user input serialized as a request.

                                                                                                                                      interface FinalizeHandlerOutput

                                                                                                                                      interface FinalizeHandlerOutput<Output extends object>
                                                                                                                                      extends InitializeHandlerOutput<Output> {}

                                                                                                                                        interface FinalizeRequestHandlerOptions

                                                                                                                                        interface FinalizeRequestHandlerOptions extends HandlerOptions {}

                                                                                                                                          property step

                                                                                                                                          step: 'finalizeRequest';

                                                                                                                                            interface FinalizeRequestMiddleware

                                                                                                                                            interface FinalizeRequestMiddleware<Input extends object, Output extends object> {}
                                                                                                                                            • A factory function that creates functions implementing the {FinalizeHandler} interface.

                                                                                                                                            call signature

                                                                                                                                            (
                                                                                                                                            next: FinalizeHandler<Input, Output>,
                                                                                                                                            context: HandlerExecutionContext
                                                                                                                                            ): FinalizeHandler<Input, Output>;
                                                                                                                                            • Parameter next

                                                                                                                                              The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.

                                                                                                                                              Parameter context

                                                                                                                                              Invariant data and functions for use by the handler.

                                                                                                                                            interface FormattedEvent

                                                                                                                                            interface FormattedEvent {}

                                                                                                                                              property headers

                                                                                                                                              headers: Uint8Array;

                                                                                                                                                property payload

                                                                                                                                                payload: Uint8Array;

                                                                                                                                                  interface GetAwsChunkedEncodingStream

                                                                                                                                                  interface GetAwsChunkedEncodingStream<StreamType = any> {}
                                                                                                                                                  • A function that returns Readable Stream which follows aws-chunked encoding stream. It optionally adds checksum if options are provided.

                                                                                                                                                  call signature

                                                                                                                                                  (
                                                                                                                                                  readableStream: StreamType,
                                                                                                                                                  options: GetAwsChunkedEncodingStreamOptions
                                                                                                                                                  ): StreamType;

                                                                                                                                                    interface GetAwsChunkedEncodingStreamOptions

                                                                                                                                                    interface GetAwsChunkedEncodingStreamOptions {}

                                                                                                                                                      property base64Encoder

                                                                                                                                                      base64Encoder?: Encoder;

                                                                                                                                                        property bodyLengthChecker

                                                                                                                                                        bodyLengthChecker: BodyLengthCalculator;

                                                                                                                                                          property checksumAlgorithmFn

                                                                                                                                                          checksumAlgorithmFn?: HashConstructor;

                                                                                                                                                            property checksumLocationName

                                                                                                                                                            checksumLocationName?: string;

                                                                                                                                                              property streamHasher

                                                                                                                                                              streamHasher?: StreamHasher;

                                                                                                                                                                interface HandlerExecutionContext

                                                                                                                                                                interface HandlerExecutionContext {}
                                                                                                                                                                • Data and helper objects that are not expected to change from one execution of a composed handler to another.

                                                                                                                                                                property logger

                                                                                                                                                                logger?: Logger;
                                                                                                                                                                • A logger that may be invoked by any handler during execution of an operation.

                                                                                                                                                                property userAgent

                                                                                                                                                                userAgent?: UserAgent;
                                                                                                                                                                • Additional user agent that inferred by middleware. It can be used to save the internal user agent sections without overriding the customUserAgent config in clients.

                                                                                                                                                                index signature

                                                                                                                                                                [key: string]: any;

                                                                                                                                                                  interface HandlerOptions

                                                                                                                                                                  interface HandlerOptions {}

                                                                                                                                                                    property name

                                                                                                                                                                    name?: string;
                                                                                                                                                                    • A unique name to refer to a middleware

                                                                                                                                                                    property step

                                                                                                                                                                    step?: Step;
                                                                                                                                                                    • Handlers are ordered using a "step" that describes the stage of command execution at which the handler will be executed. The available steps are:

                                                                                                                                                                      - initialize: The input is being prepared. Examples of typical initialization tasks include injecting default options computing derived parameters. - serialize: The input is complete and ready to be serialized. Examples of typical serialization tasks include input validation and building an HTTP request from user input. - build: The input has been serialized into an HTTP request, but that request may require further modification. Any request alterations will be applied to all retries. Examples of typical build tasks include injecting HTTP headers that describe a stable aspect of the request, such as Content-Length or a body checksum. - finalizeRequest: The request is being prepared to be sent over the wire. The request in this stage should already be semantically complete and should therefore only be altered as match the recipient's expectations. Examples of typical finalization tasks include request signing and injecting hop-by-hop headers. - deserialize: The response has arrived, the middleware here will deserialize the raw response object to structured response

                                                                                                                                                                      Unlike initialization and build handlers, which are executed once per operation execution, finalization and deserialize handlers will be executed foreach HTTP request sent.

                                                                                                                                                                      'initialize'

                                                                                                                                                                    property tags

                                                                                                                                                                    tags?: Array<string>;
                                                                                                                                                                    • A list of strings to any that identify the general purpose or important characteristics of a given handler.

                                                                                                                                                                    interface Hash

                                                                                                                                                                    interface Hash {}
                                                                                                                                                                    • An object that provides a hash of data provided in chunks to update. The hash may be performed incrementally as chunks are received or all at once when the hash is finalized, depending on the underlying implementation.

                                                                                                                                                                    method digest

                                                                                                                                                                    digest: () => Promise<Uint8Array>;
                                                                                                                                                                    • Finalizes the hash and provides a promise that will be fulfilled with the raw bytes of the calculated hash.

                                                                                                                                                                    method update

                                                                                                                                                                    update: (toHash: SourceData, encoding?: 'utf8' | 'ascii' | 'latin1') => void;
                                                                                                                                                                    • Adds a chunk of data to the hash. If a buffer is provided, the encoding argument will be ignored. If a string is provided without a specified encoding, implementations must assume UTF-8 encoding.

                                                                                                                                                                      Not all encodings are supported on all platforms, though all must support UTF-8.

                                                                                                                                                                    interface HashConstructor

                                                                                                                                                                    interface HashConstructor {}
                                                                                                                                                                    • A constructor for a hash that may be used to calculate an HMAC. Implementing classes should not directly hold the provided key in memory beyond the lexical scope of the constructor.

                                                                                                                                                                    construct signature

                                                                                                                                                                    new (secret?: SourceData): Hash;

                                                                                                                                                                      interface HeaderBag

                                                                                                                                                                      interface HeaderBag {}
                                                                                                                                                                      • A mapping of header names to string values. Multiple values for the same header should be represented as a single string with values separated by , .

                                                                                                                                                                        Keys should be considered case insensitive, even if this is not enforced by a particular implementation. For example, given the following HeaderBag, where keys differ only in case:

                                                                                                                                                                        { 'x-amz-date': '2000-01-01T00:00:00Z', 'X-Amz-Date': '2001-01-01T00:00:00Z' }

                                                                                                                                                                        The SDK may at any point during processing remove one of the object properties in favor of the other. The headers may or may not be combined, and the SDK will not deterministically select which header candidate to use.

                                                                                                                                                                      index signature

                                                                                                                                                                      [key: string]: string;

                                                                                                                                                                        interface Headers

                                                                                                                                                                        interface Headers extends Map<string, string> {}
                                                                                                                                                                        • A collection of key/value pairs with case-insensitive keys.

                                                                                                                                                                        method withHeader

                                                                                                                                                                        withHeader: (headerName: string, headerValue: string) => Headers;
                                                                                                                                                                        • Returns a new instance of Headers with the specified header set to the provided value. Does not modify the original Headers instance.

                                                                                                                                                                          Parameter headerName

                                                                                                                                                                          The name of the header to add or overwrite

                                                                                                                                                                          Parameter headerValue

                                                                                                                                                                          The value to which the header should be set

                                                                                                                                                                        method withoutHeader

                                                                                                                                                                        withoutHeader: (headerName: string) => Headers;
                                                                                                                                                                        • Returns a new instance of Headers without the specified header. Does not modify the original Headers instance.

                                                                                                                                                                          Parameter headerName

                                                                                                                                                                          The name of the header to remove

                                                                                                                                                                        interface HttpHandlerOptions

                                                                                                                                                                        interface HttpHandlerOptions {}
                                                                                                                                                                        • Represents the options that may be passed to an Http Handler.

                                                                                                                                                                        property abortSignal

                                                                                                                                                                        abortSignal?: AbortSignal;

                                                                                                                                                                          interface HttpMessage

                                                                                                                                                                          interface HttpMessage {}
                                                                                                                                                                          • Represents an HTTP message with headers and an optional static or streaming body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;

                                                                                                                                                                          property body

                                                                                                                                                                          body?: any;

                                                                                                                                                                            property headers

                                                                                                                                                                            headers: HeaderBag;

                                                                                                                                                                              interface HttpRequest

                                                                                                                                                                              interface HttpRequest extends HttpMessage, Endpoint {}
                                                                                                                                                                              • Interface an HTTP request class. Contains addressing information in addition to standard message properties.

                                                                                                                                                                              property method

                                                                                                                                                                              method: string;

                                                                                                                                                                                interface HttpResponse

                                                                                                                                                                                interface HttpResponse extends HttpMessage {}
                                                                                                                                                                                • Represents an HTTP message as received in reply to a request. Contains a numeric status code in addition to standard message properties.

                                                                                                                                                                                property statusCode

                                                                                                                                                                                statusCode: number;

                                                                                                                                                                                  interface InitializeHandler

                                                                                                                                                                                  interface InitializeHandler<Input extends object, Output extends object> {}

                                                                                                                                                                                    call signature

                                                                                                                                                                                    (args: InitializeHandlerArguments<Input>): Promise<
                                                                                                                                                                                    InitializeHandlerOutput<Output>
                                                                                                                                                                                    >;
                                                                                                                                                                                    • Asynchronously converts an input object into an output object.

                                                                                                                                                                                      Parameter args

                                                                                                                                                                                      An object containing a input to the command as well as any associated or previously generated execution artifacts.

                                                                                                                                                                                    interface InitializeHandlerArguments

                                                                                                                                                                                    interface InitializeHandlerArguments<Input extends object> {}

                                                                                                                                                                                      property input

                                                                                                                                                                                      input: Input;
                                                                                                                                                                                      • User input to a command. Reflects the userland representation of the union of data types the command can effectively handle.

                                                                                                                                                                                      interface InitializeHandlerOptions

                                                                                                                                                                                      interface InitializeHandlerOptions extends HandlerOptions {}

                                                                                                                                                                                        property step

                                                                                                                                                                                        step?: 'initialize';

                                                                                                                                                                                          interface InitializeHandlerOutput

                                                                                                                                                                                          interface InitializeHandlerOutput<Output extends object>
                                                                                                                                                                                          extends DeserializeHandlerOutput<Output> {}

                                                                                                                                                                                            property output

                                                                                                                                                                                            output: Output;

                                                                                                                                                                                              interface InitializeMiddleware

                                                                                                                                                                                              interface InitializeMiddleware<Input extends object, Output extends object> {}
                                                                                                                                                                                              • A factory function that creates functions implementing the {Handler} interface.

                                                                                                                                                                                              call signature

                                                                                                                                                                                              (
                                                                                                                                                                                              next: InitializeHandler<Input, Output>,
                                                                                                                                                                                              context: HandlerExecutionContext
                                                                                                                                                                                              ): InitializeHandler<Input, Output>;
                                                                                                                                                                                              • Parameter next

                                                                                                                                                                                                The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.

                                                                                                                                                                                                Parameter context

                                                                                                                                                                                                Invariant data and functions for use by the handler.

                                                                                                                                                                                              interface Int64

                                                                                                                                                                                              interface Int64 {}

                                                                                                                                                                                                property bytes

                                                                                                                                                                                                readonly bytes: Uint8Array;

                                                                                                                                                                                                  property toString

                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                    property valueOf

                                                                                                                                                                                                    valueOf: () => number;

                                                                                                                                                                                                      interface IntegerHeaderValue

                                                                                                                                                                                                      interface IntegerHeaderValue {}

                                                                                                                                                                                                        property type

                                                                                                                                                                                                        type: 'integer';

                                                                                                                                                                                                          property value

                                                                                                                                                                                                          value: number;

                                                                                                                                                                                                            interface Logger

                                                                                                                                                                                                            interface Logger {}
                                                                                                                                                                                                            • Represents a logger object that is available in HandlerExecutionContext throughout the middleware stack.

                                                                                                                                                                                                            method debug

                                                                                                                                                                                                            debug: (...content: any[]) => void;

                                                                                                                                                                                                              method error

                                                                                                                                                                                                              error: (...content: any[]) => void;

                                                                                                                                                                                                                method info

                                                                                                                                                                                                                info: (...content: any[]) => void;

                                                                                                                                                                                                                  method warn

                                                                                                                                                                                                                  warn: (...content: any[]) => void;

                                                                                                                                                                                                                    interface LoggerOptions

                                                                                                                                                                                                                    interface LoggerOptions {}
                                                                                                                                                                                                                    • An object consumed by Logger constructor to initiate a logger object.

                                                                                                                                                                                                                    property logger

                                                                                                                                                                                                                    logger?: Logger;

                                                                                                                                                                                                                      property logLevel

                                                                                                                                                                                                                      logLevel?: LogLevel;

                                                                                                                                                                                                                        interface LongHeaderValue

                                                                                                                                                                                                                        interface LongHeaderValue {}

                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                          type: 'long';

                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                            value: Int64;

                                                                                                                                                                                                                              interface MemoizedProvider

                                                                                                                                                                                                                              interface MemoizedProvider<T> {}
                                                                                                                                                                                                                              • A function that, when invoked, returns a promise that will be fulfilled with a value of type T. It memoizes the result from the previous invocation instead of calling the underlying resources every time.

                                                                                                                                                                                                                                You can force the provider to refresh the memoized value by invoke the function with optional parameter hash with forceRefresh boolean key and value true.

                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                A function that reads credentials from IMDS service that could return expired credentials. The SDK will keep using the expired credentials until an unretryable service error requiring a force refresh of the credentials.

                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                              (options?: { forceRefresh?: boolean }): Promise<T>;

                                                                                                                                                                                                                                interface Message

                                                                                                                                                                                                                                interface Message {}
                                                                                                                                                                                                                                • An event stream message. The headers and body properties will always be defined, with empty headers represented as an object with no keys and an empty body represented as a zero-length Uint8Array.

                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                body: Uint8Array;

                                                                                                                                                                                                                                  property headers

                                                                                                                                                                                                                                  headers: MessageHeaders;

                                                                                                                                                                                                                                    interface MessageHeaders

                                                                                                                                                                                                                                    interface MessageHeaders {}

                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                      [name: string]: MessageHeaderValue;

                                                                                                                                                                                                                                        interface MetadataBearer

                                                                                                                                                                                                                                        interface MetadataBearer {}

                                                                                                                                                                                                                                          property $metadata

                                                                                                                                                                                                                                          $metadata: ResponseMetadata;
                                                                                                                                                                                                                                          • Metadata pertaining to this request.

                                                                                                                                                                                                                                          interface MiddlewareStack

                                                                                                                                                                                                                                          interface MiddlewareStack<Input extends object, Output extends object>
                                                                                                                                                                                                                                          extends Pluggable<Input, Output> {}
                                                                                                                                                                                                                                          • A stack storing middleware. It can be resolved into a handler. It supports 2 approaches for adding middleware: 1. Adding middleware to specific step with add(). The order of middleware added into same step is determined by order of adding them. If one middleware needs to be executed at the front of the step or at the end of step, set priority options to high or low. 2. Adding middleware to location relative to known middleware with addRelativeTo(). This is useful when given middleware must be executed before or after specific middleware(toMiddleware). You can add a middleware relatively to another middleware which also added relatively. But eventually, this relative middleware chain **must** be 'anchored' by a middleware that added using add() API with absolute step and priority. This mothod will throw if specified toMiddleware is not found.

                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                          add: {
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          middleware: InitializeMiddleware<Input, Output>,
                                                                                                                                                                                                                                          options?: InitializeHandlerOptions & AbsoluteLocation
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          middleware: SerializeMiddleware<Input, Output>,
                                                                                                                                                                                                                                          options: SerializeHandlerOptions & AbsoluteLocation
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          middleware: BuildMiddleware<Input, Output>,
                                                                                                                                                                                                                                          options: BuildHandlerOptions & AbsoluteLocation
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          middleware: FinalizeRequestMiddleware<Input, Output>,
                                                                                                                                                                                                                                          options: FinalizeRequestHandlerOptions & AbsoluteLocation
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          middleware: DeserializeMiddleware<Input, Output>,
                                                                                                                                                                                                                                          options: DeserializeHandlerOptions & AbsoluteLocation
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                          • Add middleware to the stack to be executed during the "initialize" step, optionally specifying a priority, tags and name

                                                                                                                                                                                                                                          • Add middleware to the stack to be executed during the "serialize" step, optionally specifying a priority, tags and name

                                                                                                                                                                                                                                          • Add middleware to the stack to be executed during the "build" step, optionally specifying a priority, tags and name

                                                                                                                                                                                                                                          • Add middleware to the stack to be executed during the "finalizeRequest" step, optionally specifying a priority, tags and name

                                                                                                                                                                                                                                          • Add middleware to the stack to be executed during the "deserialize" step, optionally specifying a priority, tags and name

                                                                                                                                                                                                                                          method addRelativeTo

                                                                                                                                                                                                                                          addRelativeTo: (
                                                                                                                                                                                                                                          middleware: MiddlewareType<Input, Output>,
                                                                                                                                                                                                                                          options: RelativeMiddlewareOptions
                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                          • Add middleware to a stack position before or after a known middleware´╝îoptionally specifying name and tags.

                                                                                                                                                                                                                                          method clone

                                                                                                                                                                                                                                          clone: () => MiddlewareStack<Input, Output>;
                                                                                                                                                                                                                                          • Create a shallow clone of this stack. Step bindings and handler priorities and tags are preserved in the copy.

                                                                                                                                                                                                                                          method concat

                                                                                                                                                                                                                                          concat: <InputType extends Input, OutputType extends Output>(
                                                                                                                                                                                                                                          from: MiddlewareStack<InputType, OutputType>
                                                                                                                                                                                                                                          ) => MiddlewareStack<InputType, OutputType>;
                                                                                                                                                                                                                                          • Create a stack containing the middlewares in this stack as well as the middlewares in the from stack. Neither source is modified, and step bindings and handler priorities and tags are preserved in the copy.

                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                          remove: (toRemove: MiddlewareType<Input, Output> | string) => boolean;
                                                                                                                                                                                                                                          • Removes middleware from the stack.

                                                                                                                                                                                                                                            If a string is provided, it will be treated as middleware name. If a middleware is inserted with the given name, it will be removed.

                                                                                                                                                                                                                                            If a middleware class is provided, all usages thereof will be removed.

                                                                                                                                                                                                                                          method removeByTag

                                                                                                                                                                                                                                          removeByTag: (toRemove: string) => boolean;
                                                                                                                                                                                                                                          • Removes middleware that contains given tag

                                                                                                                                                                                                                                            Multiple middleware will potentially be removed

                                                                                                                                                                                                                                          method resolve

                                                                                                                                                                                                                                          resolve: <InputType extends Input, OutputType extends Output>(
                                                                                                                                                                                                                                          handler: DeserializeHandler<InputType, OutputType>,
                                                                                                                                                                                                                                          context: HandlerExecutionContext
                                                                                                                                                                                                                                          ) => InitializeHandler<InputType, OutputType>;
                                                                                                                                                                                                                                          • Builds a single handler function from zero or more middleware classes and a core handler. The core handler is meant to send command objects to AWS services and return promises that will resolve with the operation result or be rejected with an error.

                                                                                                                                                                                                                                            When a composed handler is invoked, the arguments will pass through all middleware in a defined order, and the return from the innermost handler will pass through all middleware in the reverse of that order.

                                                                                                                                                                                                                                          method use

                                                                                                                                                                                                                                          use: (pluggable: Pluggable<Input, Output>) => void;
                                                                                                                                                                                                                                          • Apply a customization function to mutate the middleware stack, often used for customizations that requires mutating multiple middleware.

                                                                                                                                                                                                                                          interface PaginationConfiguration

                                                                                                                                                                                                                                          interface PaginationConfiguration {}
                                                                                                                                                                                                                                          • Expected paginator configuration passed to an operation. Services will extend this interface definition and may type client further.

                                                                                                                                                                                                                                          property client

                                                                                                                                                                                                                                          client: Client<any, any, any>;

                                                                                                                                                                                                                                            property pageSize

                                                                                                                                                                                                                                            pageSize?: number;

                                                                                                                                                                                                                                              property startingToken

                                                                                                                                                                                                                                              startingToken?: any;

                                                                                                                                                                                                                                                property stopOnSameToken

                                                                                                                                                                                                                                                stopOnSameToken?: boolean;
                                                                                                                                                                                                                                                • For some APIs, such as CloudWatchLogs events, the next page token will always be present.

                                                                                                                                                                                                                                                  When true, this config field will have the paginator stop when the token doesn't change instead of when it is not present.

                                                                                                                                                                                                                                                interface ParsedIniData

                                                                                                                                                                                                                                                interface ParsedIniData {}

                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                  [key: string]: Profile;

                                                                                                                                                                                                                                                    interface Pluggable

                                                                                                                                                                                                                                                    interface Pluggable<Input extends object, Output extends object> {}

                                                                                                                                                                                                                                                      property applyToStack

                                                                                                                                                                                                                                                      applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
                                                                                                                                                                                                                                                      • A function that mutate the passed in middleware stack. Functions implementing this interface can add, remove, modify existing middleware stack from clients or commands

                                                                                                                                                                                                                                                      interface Profile

                                                                                                                                                                                                                                                      interface Profile {}

                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                        [key: string]: string | undefined;

                                                                                                                                                                                                                                                          interface Provider

                                                                                                                                                                                                                                                          interface Provider<T> {}
                                                                                                                                                                                                                                                          • A function that, when invoked, returns a promise that will be fulfilled with a value of type T.

                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                            A function that reads credentials from shared SDK configuration files, assuming roles and collecting MFA tokens as necessary.

                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                          (): Promise<T>;

                                                                                                                                                                                                                                                            interface QueryParameterBag

                                                                                                                                                                                                                                                            interface QueryParameterBag {}
                                                                                                                                                                                                                                                            • A mapping of query parameter names to strings or arrays of strings, with the second being used when a parameter contains a list of values. Value can be set to null when query is not in key-value pairs shape

                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                            [key: string]: string | Array<string> | null;

                                                                                                                                                                                                                                                              interface randomValues

                                                                                                                                                                                                                                                              interface randomValues {}
                                                                                                                                                                                                                                                              • A function that returns a promise fulfilled with bytes from a cryptographically secure pseudorandom number generator.

                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                              (byteLength: number): Promise<Uint8Array>;

                                                                                                                                                                                                                                                                interface RegionInfo

                                                                                                                                                                                                                                                                interface RegionInfo {}
                                                                                                                                                                                                                                                                • Object containing regionalization information of AWS services.

                                                                                                                                                                                                                                                                property hostname

                                                                                                                                                                                                                                                                hostname: string;

                                                                                                                                                                                                                                                                  property partition

                                                                                                                                                                                                                                                                  partition: string;

                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                    path?: string;

                                                                                                                                                                                                                                                                      property signingRegion

                                                                                                                                                                                                                                                                      signingRegion?: string;

                                                                                                                                                                                                                                                                        property signingService

                                                                                                                                                                                                                                                                        signingService?: string;

                                                                                                                                                                                                                                                                          interface RegionInfoProvider

                                                                                                                                                                                                                                                                          interface RegionInfoProvider {}
                                                                                                                                                                                                                                                                          • Function returns designated service's regionalization information from given region. Each service client comes with its regionalization provider. it serves to provide the default values of related configurations

                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                          (region: string, options?: RegionInfoProviderOptions): Promise<
                                                                                                                                                                                                                                                                          RegionInfo | undefined
                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                            interface RegionInfoProviderOptions

                                                                                                                                                                                                                                                                            interface RegionInfoProviderOptions {}

                                                                                                                                                                                                                                                                            property useDualstackEndpoint

                                                                                                                                                                                                                                                                            useDualstackEndpoint: boolean;
                                                                                                                                                                                                                                                                            • Enables IPv6/IPv4 dualstack endpoint. false

                                                                                                                                                                                                                                                                            property useFipsEndpoint

                                                                                                                                                                                                                                                                            useFipsEndpoint: boolean;
                                                                                                                                                                                                                                                                            • Enables FIPS compatible endpoints. false

                                                                                                                                                                                                                                                                            interface RelativeLocation

                                                                                                                                                                                                                                                                            interface RelativeLocation {}

                                                                                                                                                                                                                                                                              property relation

                                                                                                                                                                                                                                                                              relation: Relation;
                                                                                                                                                                                                                                                                              • Specify the relation to be before or after a know middleware.

                                                                                                                                                                                                                                                                              property toMiddleware

                                                                                                                                                                                                                                                                              toMiddleware: string;
                                                                                                                                                                                                                                                                              • A known middleware name to indicate inserting middleware's location.

                                                                                                                                                                                                                                                                              interface RequestHandler

                                                                                                                                                                                                                                                                              interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {}

                                                                                                                                                                                                                                                                                property destroy

                                                                                                                                                                                                                                                                                destroy?: () => void;

                                                                                                                                                                                                                                                                                  property handle

                                                                                                                                                                                                                                                                                  handle: (
                                                                                                                                                                                                                                                                                  request: RequestType,
                                                                                                                                                                                                                                                                                  handlerOptions?: HandlerOptions
                                                                                                                                                                                                                                                                                  ) => Promise<RequestHandlerOutput<ResponseType>>;

                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                    metadata?: RequestHandlerMetadata;
                                                                                                                                                                                                                                                                                    • metadata contains information of a handler. For example 'h2' refers this handler is for handling HTTP/2 requests, whereas 'h1' refers handling HTTP1 requests

                                                                                                                                                                                                                                                                                    interface RequestHandlerMetadata

                                                                                                                                                                                                                                                                                    interface RequestHandlerMetadata {}

                                                                                                                                                                                                                                                                                      property handlerProtocol

                                                                                                                                                                                                                                                                                      handlerProtocol: string;

                                                                                                                                                                                                                                                                                        interface RequestPresigner

                                                                                                                                                                                                                                                                                        interface RequestPresigner {}

                                                                                                                                                                                                                                                                                          method presign

                                                                                                                                                                                                                                                                                          presign: (
                                                                                                                                                                                                                                                                                          requestToSign: HttpRequest,
                                                                                                                                                                                                                                                                                          options?: RequestPresigningArguments
                                                                                                                                                                                                                                                                                          ) => Promise<HttpRequest>;
                                                                                                                                                                                                                                                                                          • Signs a request for future use.

                                                                                                                                                                                                                                                                                            The request will be valid until either the provided expiration time has passed or the underlying credentials have expired.

                                                                                                                                                                                                                                                                                            Parameter requestToSign

                                                                                                                                                                                                                                                                                            The request that should be signed.

                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                            Additional signing options.

                                                                                                                                                                                                                                                                                          interface RequestPresigningArguments

                                                                                                                                                                                                                                                                                          interface RequestPresigningArguments extends RequestSigningArguments {}

                                                                                                                                                                                                                                                                                            property expiresIn

                                                                                                                                                                                                                                                                                            expiresIn?: number;
                                                                                                                                                                                                                                                                                            • The number of seconds before the presigned URL expires

                                                                                                                                                                                                                                                                                            property unhoistableHeaders

                                                                                                                                                                                                                                                                                            unhoistableHeaders?: Set<string>;
                                                                                                                                                                                                                                                                                            • A set of strings whose representing headers that should not be hoisted to presigned request's query string. If not supplied, the presigner moves all the AWS-specific headers (starting with x-amz-) to the request query string. If supplied, these headers remain in the presigned request's header. All headers in the provided request will have their names converted to lower case and then checked for existence in the unhoistableHeaders set.

                                                                                                                                                                                                                                                                                            interface RequestSerializer

                                                                                                                                                                                                                                                                                            interface RequestSerializer<Request, Context extends EndpointBearer = any> {}

                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                              (input: any, context: Context): Promise<Request>;
                                                                                                                                                                                                                                                                                              • Converts the provided input into a request object

                                                                                                                                                                                                                                                                                                Parameter input

                                                                                                                                                                                                                                                                                                The user input to serialize.

                                                                                                                                                                                                                                                                                                Parameter context

                                                                                                                                                                                                                                                                                                Context containing runtime-specific util functions.

                                                                                                                                                                                                                                                                                              interface RequestSigner

                                                                                                                                                                                                                                                                                              interface RequestSigner {}
                                                                                                                                                                                                                                                                                              • An object that signs request objects with AWS credentials using one of the AWS authentication protocols.

                                                                                                                                                                                                                                                                                              method sign

                                                                                                                                                                                                                                                                                              sign: (
                                                                                                                                                                                                                                                                                              requestToSign: HttpRequest,
                                                                                                                                                                                                                                                                                              options?: RequestSigningArguments
                                                                                                                                                                                                                                                                                              ) => Promise<HttpRequest>;
                                                                                                                                                                                                                                                                                              • Sign the provided request for immediate dispatch.

                                                                                                                                                                                                                                                                                              interface RequestSigningArguments

                                                                                                                                                                                                                                                                                              interface RequestSigningArguments extends SigningArguments {}

                                                                                                                                                                                                                                                                                                property signableHeaders

                                                                                                                                                                                                                                                                                                signableHeaders?: Set<string>;
                                                                                                                                                                                                                                                                                                • A set of strings whose members represents headers that should be signed. Any values passed here will override those provided via unsignableHeaders, allowing them to be signed.

                                                                                                                                                                                                                                                                                                  All headers in the provided request will have their names converted to lower case before signing.

                                                                                                                                                                                                                                                                                                property unsignableHeaders

                                                                                                                                                                                                                                                                                                unsignableHeaders?: Set<string>;
                                                                                                                                                                                                                                                                                                • A set of strings whose members represents headers that cannot be signed. All headers in the provided request will have their names converted to lower case and then checked for existence in the unsignableHeaders set.

                                                                                                                                                                                                                                                                                                interface ResolvedHttpResponse

                                                                                                                                                                                                                                                                                                interface ResolvedHttpResponse extends HttpResponse {}
                                                                                                                                                                                                                                                                                                • Represents HTTP message whose body has been resolved to a string. This is used in parsing http message.

                                                                                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                                                                                body: string;

                                                                                                                                                                                                                                                                                                  interface ResponseDeserializer

                                                                                                                                                                                                                                                                                                  interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {}

                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                    (output: ResponseType, context: Context): Promise<OutputType>;
                                                                                                                                                                                                                                                                                                    • Converts the output of an operation into JavaScript types.

                                                                                                                                                                                                                                                                                                      Parameter output

                                                                                                                                                                                                                                                                                                      The HTTP response received from the service

                                                                                                                                                                                                                                                                                                      Parameter context

                                                                                                                                                                                                                                                                                                      context containing runtime-specific util functions.

                                                                                                                                                                                                                                                                                                    interface ResponseMetadata

                                                                                                                                                                                                                                                                                                    interface ResponseMetadata {}

                                                                                                                                                                                                                                                                                                      property attempts

                                                                                                                                                                                                                                                                                                      attempts?: number;
                                                                                                                                                                                                                                                                                                      • The number of times this operation was attempted.

                                                                                                                                                                                                                                                                                                      property cfId

                                                                                                                                                                                                                                                                                                      cfId?: string;
                                                                                                                                                                                                                                                                                                      • A tertiary identifier for the last request sent. Used for debugging.

                                                                                                                                                                                                                                                                                                      property extendedRequestId

                                                                                                                                                                                                                                                                                                      extendedRequestId?: string;
                                                                                                                                                                                                                                                                                                      • A secondary identifier for the last request sent. Used for debugging.

                                                                                                                                                                                                                                                                                                      property httpStatusCode

                                                                                                                                                                                                                                                                                                      httpStatusCode?: number;
                                                                                                                                                                                                                                                                                                      • The status code of the last HTTP response received for this operation.

                                                                                                                                                                                                                                                                                                      property requestId

                                                                                                                                                                                                                                                                                                      requestId?: string;
                                                                                                                                                                                                                                                                                                      • A unique identifier for the last request sent for this operation. Often requested by AWS service teams to aid in debugging.

                                                                                                                                                                                                                                                                                                      property totalRetryDelay

                                                                                                                                                                                                                                                                                                      totalRetryDelay?: number;
                                                                                                                                                                                                                                                                                                      • The total amount of time (in milliseconds) that was spent waiting between retry attempts.

                                                                                                                                                                                                                                                                                                      interface RetryableTrait

                                                                                                                                                                                                                                                                                                      interface RetryableTrait {}
                                                                                                                                                                                                                                                                                                      • A structure shape with the error trait. https://awslabs.github.io/smithy/spec/core.html#retryable-trait

                                                                                                                                                                                                                                                                                                      property throttling

                                                                                                                                                                                                                                                                                                      readonly throttling?: boolean;
                                                                                                                                                                                                                                                                                                      • Indicates that the error is a retryable throttling error.

                                                                                                                                                                                                                                                                                                      interface RetryStrategy

                                                                                                                                                                                                                                                                                                      interface RetryStrategy {}
                                                                                                                                                                                                                                                                                                      • Interface that specifies the retry behavior

                                                                                                                                                                                                                                                                                                      property mode

                                                                                                                                                                                                                                                                                                      mode?: string;
                                                                                                                                                                                                                                                                                                      • The retry mode describing how the retry strategy control the traffic flow.

                                                                                                                                                                                                                                                                                                      property retry

                                                                                                                                                                                                                                                                                                      retry: <Input extends object, Output extends MetadataBearer>(
                                                                                                                                                                                                                                                                                                      next: FinalizeHandler<Input, Output>,
                                                                                                                                                                                                                                                                                                      args: FinalizeHandlerArguments<Input>
                                                                                                                                                                                                                                                                                                      ) => Promise<FinalizeHandlerOutput<Output>>;
                                                                                                                                                                                                                                                                                                      • the retry behavior the will invoke the next handler and handle the retry accordingly. This function should also update the $metadata from the response accordingly.

                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                      interface SerdeContext

                                                                                                                                                                                                                                                                                                      interface SerdeContext extends EndpointBearer {}
                                                                                                                                                                                                                                                                                                      • Request and Response serde util functions and settings for AWS services

                                                                                                                                                                                                                                                                                                      property base64Decoder

                                                                                                                                                                                                                                                                                                      base64Decoder: Decoder;

                                                                                                                                                                                                                                                                                                        property base64Encoder

                                                                                                                                                                                                                                                                                                        base64Encoder: Encoder;

                                                                                                                                                                                                                                                                                                          property disableHostPrefix

                                                                                                                                                                                                                                                                                                          disableHostPrefix: boolean;

                                                                                                                                                                                                                                                                                                            property requestHandler

                                                                                                                                                                                                                                                                                                            requestHandler: RequestHandler<any, any>;

                                                                                                                                                                                                                                                                                                              property streamCollector

                                                                                                                                                                                                                                                                                                              streamCollector: StreamCollector;

                                                                                                                                                                                                                                                                                                                property utf8Decoder

                                                                                                                                                                                                                                                                                                                utf8Decoder: Decoder;

                                                                                                                                                                                                                                                                                                                  property utf8Encoder

                                                                                                                                                                                                                                                                                                                  utf8Encoder: Encoder;

                                                                                                                                                                                                                                                                                                                    interface SerializeHandler

                                                                                                                                                                                                                                                                                                                    interface SerializeHandler<Input extends object, Output extends object> {}

                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                      (args: SerializeHandlerArguments<Input>): Promise<
                                                                                                                                                                                                                                                                                                                      SerializeHandlerOutput<Output>
                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                      • Asynchronously converts an input object into an output object.

                                                                                                                                                                                                                                                                                                                        Parameter args

                                                                                                                                                                                                                                                                                                                        An object containing a input to the command as well as any associated or previously generated execution artifacts.

                                                                                                                                                                                                                                                                                                                      interface SerializeHandlerArguments

                                                                                                                                                                                                                                                                                                                      interface SerializeHandlerArguments<Input extends object>
                                                                                                                                                                                                                                                                                                                      extends InitializeHandlerArguments<Input> {}

                                                                                                                                                                                                                                                                                                                        property request

                                                                                                                                                                                                                                                                                                                        request?: unknown;
                                                                                                                                                                                                                                                                                                                        • The user input serialized as a request object. The request object is unknown, so you cannot modify it directly. When work with request, you need to guard its type to e.g. HttpRequest with 'instanceof' operand

                                                                                                                                                                                                                                                                                                                          During the build phase of the execution of a middleware stack, a built request may or may not be available.

                                                                                                                                                                                                                                                                                                                        interface SerializeHandlerOptions

                                                                                                                                                                                                                                                                                                                        interface SerializeHandlerOptions extends HandlerOptions {}

                                                                                                                                                                                                                                                                                                                          property step

                                                                                                                                                                                                                                                                                                                          step: 'serialize';

                                                                                                                                                                                                                                                                                                                            interface SerializeHandlerOutput

                                                                                                                                                                                                                                                                                                                            interface SerializeHandlerOutput<Output extends object>
                                                                                                                                                                                                                                                                                                                            extends InitializeHandlerOutput<Output> {}

                                                                                                                                                                                                                                                                                                                              interface SerializeMiddleware

                                                                                                                                                                                                                                                                                                                              interface SerializeMiddleware<Input extends object, Output extends object> {}
                                                                                                                                                                                                                                                                                                                              • A factory function that creates functions implementing the {BuildHandler} interface.

                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                              next: SerializeHandler<Input, Output>,
                                                                                                                                                                                                                                                                                                                              context: HandlerExecutionContext
                                                                                                                                                                                                                                                                                                                              ): SerializeHandler<Input, Output>;
                                                                                                                                                                                                                                                                                                                              • Parameter next

                                                                                                                                                                                                                                                                                                                                The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.

                                                                                                                                                                                                                                                                                                                                Parameter context

                                                                                                                                                                                                                                                                                                                                Invariant data and functions for use by the handler.

                                                                                                                                                                                                                                                                                                                              interface SharedConfigFiles

                                                                                                                                                                                                                                                                                                                              interface SharedConfigFiles {}

                                                                                                                                                                                                                                                                                                                                property configFile

                                                                                                                                                                                                                                                                                                                                configFile: ParsedIniData;

                                                                                                                                                                                                                                                                                                                                  property credentialsFile

                                                                                                                                                                                                                                                                                                                                  credentialsFile: ParsedIniData;

                                                                                                                                                                                                                                                                                                                                    interface ShortHeaderValue

                                                                                                                                                                                                                                                                                                                                    interface ShortHeaderValue {}

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: 'short';

                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                        value: number;

                                                                                                                                                                                                                                                                                                                                          interface SigningArguments

                                                                                                                                                                                                                                                                                                                                          interface SigningArguments {}

                                                                                                                                                                                                                                                                                                                                            property signingDate

                                                                                                                                                                                                                                                                                                                                            signingDate?: DateInput;
                                                                                                                                                                                                                                                                                                                                            • The date and time to be used as signature metadata. This value should be a Date object, a unix (epoch) timestamp, or a string that can be understood by the JavaScript Date constructor.If not supplied, the value returned by new Date() will be used.

                                                                                                                                                                                                                                                                                                                                            property signingRegion

                                                                                                                                                                                                                                                                                                                                            signingRegion?: string;
                                                                                                                                                                                                                                                                                                                                            • The region name to sign the request. It will override the signing region of the signer in current invocation

                                                                                                                                                                                                                                                                                                                                            property signingService

                                                                                                                                                                                                                                                                                                                                            signingService?: string;
                                                                                                                                                                                                                                                                                                                                            • The service signing name. It will override the service name of the signer in current invocation

                                                                                                                                                                                                                                                                                                                                            interface SmithyException

                                                                                                                                                                                                                                                                                                                                            interface SmithyException {}
                                                                                                                                                                                                                                                                                                                                            • Type that is implemented by all Smithy shapes marked with the error trait.

                                                                                                                                                                                                                                                                                                                                              Deprecated

                                                                                                                                                                                                                                                                                                                                            property $fault

                                                                                                                                                                                                                                                                                                                                            readonly $fault: 'client' | 'server';
                                                                                                                                                                                                                                                                                                                                            • Whether the client or server are at fault.

                                                                                                                                                                                                                                                                                                                                            property $response

                                                                                                                                                                                                                                                                                                                                            readonly $response?: HttpResponse;
                                                                                                                                                                                                                                                                                                                                            • Reference to low-level HTTP response object.

                                                                                                                                                                                                                                                                                                                                            property $retryable

                                                                                                                                                                                                                                                                                                                                            readonly $retryable?: RetryableTrait;
                                                                                                                                                                                                                                                                                                                                            • Indicates that an error MAY be retried by the client.

                                                                                                                                                                                                                                                                                                                                            property $service

                                                                                                                                                                                                                                                                                                                                            readonly $service?: string;
                                                                                                                                                                                                                                                                                                                                            • The service that encountered the exception.

                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                            readonly name: string;
                                                                                                                                                                                                                                                                                                                                            • The shape ID name of the exception.

                                                                                                                                                                                                                                                                                                                                            interface StreamCollector

                                                                                                                                                                                                                                                                                                                                            interface StreamCollector {}

                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                              (stream: any): Promise<Uint8Array>;
                                                                                                                                                                                                                                                                                                                                              • A function that converts a stream into an array of bytes.

                                                                                                                                                                                                                                                                                                                                                Parameter stream

                                                                                                                                                                                                                                                                                                                                                The low-level native stream from browser or Nodejs runtime

                                                                                                                                                                                                                                                                                                                                              interface StreamHasher

                                                                                                                                                                                                                                                                                                                                              interface StreamHasher<StreamType = any> {}
                                                                                                                                                                                                                                                                                                                                              • A function that calculates the hash of a data stream. Determining the hash will consume the stream, so only replayable streams should be provided to an implementation of this interface.

                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                              (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;

                                                                                                                                                                                                                                                                                                                                                interface StringHeaderValue

                                                                                                                                                                                                                                                                                                                                                interface StringHeaderValue {}

                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                  type: 'string';

                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                                                                                                      interface StringSigner

                                                                                                                                                                                                                                                                                                                                                      interface StringSigner {}

                                                                                                                                                                                                                                                                                                                                                        method sign

                                                                                                                                                                                                                                                                                                                                                        sign: (stringToSign: string, options?: SigningArguments) => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                        • Sign the provided stringToSign for use outside of the context of request signing. Typical uses include signed policy generation.

                                                                                                                                                                                                                                                                                                                                                        interface Terminalware

                                                                                                                                                                                                                                                                                                                                                        interface Terminalware {}
                                                                                                                                                                                                                                                                                                                                                        • A factory function that creates the terminal handler atop which a middleware stack sits.

                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                        <Input extends object, Output extends object>(
                                                                                                                                                                                                                                                                                                                                                        context: HandlerExecutionContext
                                                                                                                                                                                                                                                                                                                                                        ): DeserializeHandler<Input, Output>;

                                                                                                                                                                                                                                                                                                                                                          interface TimestampHeaderValue

                                                                                                                                                                                                                                                                                                                                                          interface TimestampHeaderValue {}

                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                            type: 'timestamp';

                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                              value: Date;

                                                                                                                                                                                                                                                                                                                                                                interface UrlParser

                                                                                                                                                                                                                                                                                                                                                                interface UrlParser {}
                                                                                                                                                                                                                                                                                                                                                                • Parses a URL in string form into an Endpoint object.

                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                (url: string): Endpoint;

                                                                                                                                                                                                                                                                                                                                                                  interface UuidHeaderValue

                                                                                                                                                                                                                                                                                                                                                                  interface UuidHeaderValue {}

                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                    type: 'uuid';

                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                                        interface WaiterConfiguration

                                                                                                                                                                                                                                                                                                                                                                        interface WaiterConfiguration<Client> {}

                                                                                                                                                                                                                                                                                                                                                                          property abortController

                                                                                                                                                                                                                                                                                                                                                                          abortController?: AbortController;
                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                            Use abortSignal Abort controller. Used for ending the waiter early.

                                                                                                                                                                                                                                                                                                                                                                          property abortSignal

                                                                                                                                                                                                                                                                                                                                                                          abortSignal?: AbortController['signal'];
                                                                                                                                                                                                                                                                                                                                                                          • Abort Signal. Used for ending the waiter early.

                                                                                                                                                                                                                                                                                                                                                                          property client

                                                                                                                                                                                                                                                                                                                                                                          client: Client;
                                                                                                                                                                                                                                                                                                                                                                          • Required service client

                                                                                                                                                                                                                                                                                                                                                                          property maxDelay

                                                                                                                                                                                                                                                                                                                                                                          maxDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                          • The maximum amount of time to delay between retries in seconds. This is the ceiling of the exponential backoff. This value defaults to service default if not specified. If specified, this value MUST be greater than or equal to 1.

                                                                                                                                                                                                                                                                                                                                                                          property maxWaitTime

                                                                                                                                                                                                                                                                                                                                                                          maxWaitTime: number;
                                                                                                                                                                                                                                                                                                                                                                          • The amount of time in seconds a user is willing to wait for a waiter to complete.

                                                                                                                                                                                                                                                                                                                                                                          property minDelay

                                                                                                                                                                                                                                                                                                                                                                          minDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                          • The minimum amount of time to delay between retries in seconds. This is the floor of the exponential backoff. This value defaults to service default if not specified. This value MUST be less than or equal to maxDelay and greater than 0.

                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                          type CredentialProvider

                                                                                                                                                                                                                                                                                                                                                                          type CredentialProvider = Provider<Credentials>;

                                                                                                                                                                                                                                                                                                                                                                            type DateInput

                                                                                                                                                                                                                                                                                                                                                                            type DateInput = number | string | Date;
                                                                                                                                                                                                                                                                                                                                                                            • A {Date} object, a unix (epoch) timestamp in seconds, or a string that can be understood by the JavaScript {Date} constructor.

                                                                                                                                                                                                                                                                                                                                                                            type DocumentType

                                                                                                                                                                                                                                                                                                                                                                            type DocumentType =
                                                                                                                                                                                                                                                                                                                                                                            | null
                                                                                                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                            | DocumentType[]
                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                            [prop: string]: DocumentType;
                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                            • A document type represents an untyped JSON-like value.

                                                                                                                                                                                                                                                                                                                                                                              Not all protocols support document types, and the serialization format of a document type is protocol specific. All JSON protocols SHOULD support document types and they SHOULD serialize document types inline as normal JSON values.

                                                                                                                                                                                                                                                                                                                                                                            type Handler

                                                                                                                                                                                                                                                                                                                                                                            type Handler<Input extends object, Output extends object> = InitializeHandler<
                                                                                                                                                                                                                                                                                                                                                                            Input,
                                                                                                                                                                                                                                                                                                                                                                            Output
                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                              type LogLevel

                                                                                                                                                                                                                                                                                                                                                                              type LogLevel = 'all' | 'log' | 'info' | 'warn' | 'error' | 'off';
                                                                                                                                                                                                                                                                                                                                                                              • A list of logger's log level. These levels are sorted in order of increasing severity. Each log level includes itself and all the levels behind itself.

                                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                                new Logger({logLevel: 'warn'}) will print all the warn and error message.

                                                                                                                                                                                                                                                                                                                                                                              type MessageHeaderValue

                                                                                                                                                                                                                                                                                                                                                                              type MessageHeaderValue =
                                                                                                                                                                                                                                                                                                                                                                              | BooleanHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | ByteHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | ShortHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | IntegerHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | LongHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | BinaryHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | StringHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | TimestampHeaderValue
                                                                                                                                                                                                                                                                                                                                                                              | UuidHeaderValue;

                                                                                                                                                                                                                                                                                                                                                                                type MiddlewareType

                                                                                                                                                                                                                                                                                                                                                                                type MiddlewareType<Input extends object, Output extends object> =
                                                                                                                                                                                                                                                                                                                                                                                | InitializeMiddleware<Input, Output>
                                                                                                                                                                                                                                                                                                                                                                                | SerializeMiddleware<Input, Output>
                                                                                                                                                                                                                                                                                                                                                                                | BuildMiddleware<Input, Output>
                                                                                                                                                                                                                                                                                                                                                                                | FinalizeRequestMiddleware<Input, Output>
                                                                                                                                                                                                                                                                                                                                                                                | DeserializeMiddleware<Input, Output>;

                                                                                                                                                                                                                                                                                                                                                                                  type Paginator

                                                                                                                                                                                                                                                                                                                                                                                  type Paginator<T> = AsyncGenerator<T, T, unknown>;
                                                                                                                                                                                                                                                                                                                                                                                  • Expected type definition of a paginator.

                                                                                                                                                                                                                                                                                                                                                                                  type Priority

                                                                                                                                                                                                                                                                                                                                                                                  type Priority = 'high' | 'normal' | 'low';

                                                                                                                                                                                                                                                                                                                                                                                    type Relation

                                                                                                                                                                                                                                                                                                                                                                                    type Relation = 'before' | 'after';

                                                                                                                                                                                                                                                                                                                                                                                      type RelativeMiddlewareOptions

                                                                                                                                                                                                                                                                                                                                                                                      type RelativeMiddlewareOptions = RelativeLocation & Omit<HandlerOptions, 'step'>;

                                                                                                                                                                                                                                                                                                                                                                                        type RequestHandlerOutput

                                                                                                                                                                                                                                                                                                                                                                                        type RequestHandlerOutput<ResponseType> = {
                                                                                                                                                                                                                                                                                                                                                                                        response: ResponseType;
                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                          type SdkError

                                                                                                                                                                                                                                                                                                                                                                                          type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;
                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                          type SourceData

                                                                                                                                                                                                                                                                                                                                                                                          type SourceData = string | ArrayBuffer | ArrayBufferView;

                                                                                                                                                                                                                                                                                                                                                                                            type Step

                                                                                                                                                                                                                                                                                                                                                                                            type Step = 'initialize' | 'serialize' | 'build' | 'finalizeRequest' | 'deserialize';

                                                                                                                                                                                                                                                                                                                                                                                              type UserAgent

                                                                                                                                                                                                                                                                                                                                                                                              type UserAgent = UserAgentPair[];
                                                                                                                                                                                                                                                                                                                                                                                              • User agent data that to be put into the request's user agent.

                                                                                                                                                                                                                                                                                                                                                                                              type UserAgentPair

                                                                                                                                                                                                                                                                                                                                                                                              type UserAgentPair = [name: string, version?: string];
                                                                                                                                                                                                                                                                                                                                                                                              • A tuple that represents an API name and optional version of a library built using the AWS SDK.

                                                                                                                                                                                                                                                                                                                                                                                              Package Files (20)

                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@aws-sdk/types.

                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@aws-sdk/types)
                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@aws-sdk/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>