@aws-sdk/types

  • Version 3.296.0
  • Published
  • 114 kB
  • 1 dependency
  • 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

Enums

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

    Modifiers

    • @public

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 {}
  • Modifiers

    • @public

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

      Modifiers

      • @public

    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 {}
    • Modifiers

      • @public

    property priority

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

    interface AnonymousIdentity

    interface AnonymousIdentity extends Identity {}
    • Modifiers

      • @public

    interface AwsCredentialIdentity

    interface AwsCredentialIdentity extends Identity {}
    • Modifiers

      • @public

    property accessKeyId

    readonly accessKeyId: string;
    • AWS access key ID

    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 BinaryHeaderValue

    interface BinaryHeaderValue {}
    • Modifiers

      • @public

    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.

          Modifiers

          • @public

        call signature

        (body: any): number | undefined;

          interface BooleanHeaderValue

          interface BooleanHeaderValue {}
          • Modifiers

            • @public

          property type

          type: 'boolean';

            property value

            value: boolean;

              interface BuildHandler

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

                • @public

              call signature

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

                interface BuildHandlerArguments

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

                  • @public

                interface BuildHandlerOptions

                interface BuildHandlerOptions extends HandlerOptions {}
                • Modifiers

                  • @public

                property step

                step: 'build';

                  interface BuildHandlerOutput

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

                    • @public

                  interface BuildMiddleware

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

                    • @public

                  call signature

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

                    interface ByteHeaderValue

                    interface ByteHeaderValue {}
                    • Modifiers

                      • @public

                    property type

                    type: 'byte';

                      property value

                      value: number;

                        interface Checksum

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

                          It's recommended to compute checksum incrementally to avoid reading the entire payload in memory.

                          A class that implements this interface may accept an optional secret key in its constructor while computing checksum value, when using HMAC. If provided, this secret key would be used when computing checksum.

                          Modifiers

                          • @public

                        property digestLength

                        digestLength?: number;
                        • Constant length of the digest created by the algorithm in bytes.

                        method copy

                        copy: () => Checksum;
                        • Creates a new checksum object that contains a deep copy of the internal state of the current Checksum object.

                        method digest

                        digest: () => Promise<Uint8Array>;
                        • Returns the digest of all of the data passed.

                        method mark

                        mark: (readLimit: number) => void;
                        • Allows marking a checksum for checksums that support the ability to mark and reset.

                          Parameter readLimit

                          The maximum limit of bytes that can be read before the mark position becomes invalid.

                        method reset

                        reset: () => void;
                        • Resets the checksum to its initial value.

                        method update

                        update: (chunk: Uint8Array) => void;
                        • Adds a chunk of data for which checksum needs to be computed. This can be called many times with new data as it is streamed.

                          Implementations may override this method which passes second param which makes Checksum object stateless.

                          Parameter chunk

                          The buffer to update checksum with.

                        interface ChecksumConstructor

                        interface ChecksumConstructor {}
                        • A constructor for a Checksum 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.

                          Modifiers

                          • @public

                        construct signature

                        new (secret?: SourceData): Checksum;

                          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
                                  > {}
                                  • Modifiers

                                    • @public

                                  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 extends AwsCredentialIdentity {}
                                        • An object representing temporary or permanent AWS credentials.

                                          Modifiers

                                          • @public

                                          Deprecated

                                          Use AwsCredentialIdentity

                                        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'.

                                          Modifiers

                                          • @public

                                        call signature

                                        (input: string): Uint8Array;

                                          interface DeserializeHandler

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

                                            • @public

                                          call signature

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

                                            interface DeserializeHandlerArguments

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

                                              • @public

                                            interface DeserializeHandlerOptions

                                            interface DeserializeHandlerOptions extends HandlerOptions {}
                                            • Modifiers

                                              • @public

                                            property step

                                            step: 'deserialize';

                                              interface DeserializeHandlerOutput

                                              interface DeserializeHandlerOutput<Output extends object> {}
                                              • Modifiers

                                                • @public

                                              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> {}
                                                • Modifiers

                                                  • @public

                                                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]).

                                                    Modifiers

                                                    • @public

                                                  call signature

                                                  (input: Uint8Array): string;

                                                    interface Endpoint

                                                    interface Endpoint {}
                                                    • Modifiers

                                                      • @public

                                                      Deprecated

                                                      use EndpointV2 from @aws-sdk/types.

                                                    property hostname

                                                    hostname: string;

                                                      property path

                                                      path: string;

                                                        property port

                                                        port?: number;

                                                          property protocol

                                                          protocol: string;

                                                            property query

                                                            query?: QueryParameterBag;

                                                              interface EndpointARN

                                                              interface EndpointARN {}
                                                              • Modifiers

                                                                • @public

                                                              property accountId

                                                              accountId: string;

                                                                property partition

                                                                partition: string;

                                                                  property region

                                                                  region: string;

                                                                    property resourceId

                                                                    resourceId: Array<string>;

                                                                      property service

                                                                      service: string;

                                                                        interface EndpointBearer

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

                                                                          Modifiers

                                                                          • @public

                                                                        property endpoint

                                                                        endpoint: Provider<Endpoint>;

                                                                          interface EndpointPartition

                                                                          interface EndpointPartition {}
                                                                          • Modifiers

                                                                            • @public

                                                                          property dnsSuffix

                                                                          dnsSuffix: string;

                                                                            property dualStackDnsSuffix

                                                                            dualStackDnsSuffix: string;

                                                                              property name

                                                                              name: string;

                                                                                property supportsDualStack

                                                                                supportsDualStack: boolean;

                                                                                  property supportsFIPS

                                                                                  supportsFIPS: boolean;

                                                                                    interface EndpointURL

                                                                                    interface EndpointURL {}
                                                                                    • Modifiers

                                                                                      • @public

                                                                                    property authority

                                                                                    authority: string;
                                                                                    • The authority is the host and optional port component of the URL.

                                                                                    property isIp

                                                                                    isIp: boolean;
                                                                                    • A boolean indicating whether the authority is an IP address.

                                                                                    property normalizedPath

                                                                                    normalizedPath: string;
                                                                                    • The parsed path segment of the URL. This value is guranteed to start and end with a "/".

                                                                                    property path

                                                                                    path: string;
                                                                                    • The parsed path segment of the URL. This value is as-is as provided by the user.

                                                                                    property scheme

                                                                                    scheme: EndpointURLScheme;
                                                                                    • The URL scheme such as http or https.

                                                                                    interface EndpointV2

                                                                                    interface EndpointV2 {}
                                                                                    • Modifiers

                                                                                      • @public

                                                                                    property headers

                                                                                    headers?: Record<string, string[]>;

                                                                                      property properties

                                                                                      properties?: {
                                                                                      authSchemes?: AuthScheme[];
                                                                                      } & Record<string, EndpointObjectProperty>;

                                                                                        property url

                                                                                        url: URL;

                                                                                          interface EventSigner

                                                                                          interface EventSigner {}
                                                                                          • Modifiers

                                                                                            • @public

                                                                                          method sign

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

                                                                                          interface EventSigningArguments

                                                                                          interface EventSigningArguments extends SigningArguments {}
                                                                                          • Modifiers

                                                                                            • @public

                                                                                          property priorSignature

                                                                                          priorSignature: string;

                                                                                            interface EventStreamMarshaller

                                                                                            interface EventStreamMarshaller<StreamType = any> {}
                                                                                            • An interface which provides functions for serializing and deserializing binary event stream to/from corresponsing modeled shape.

                                                                                              Modifiers

                                                                                              • @public

                                                                                            property deserialize

                                                                                            deserialize: EventStreamMarshallerDeserFn<StreamType>;

                                                                                              property serialize

                                                                                              serialize: EventStreamMarshallerSerFn<StreamType>;

                                                                                                interface EventStreamMarshallerDeserFn

                                                                                                interface EventStreamMarshallerDeserFn<StreamType> {}
                                                                                                • A function which deserializes binary event stream message into modeled shape.

                                                                                                  Modifiers

                                                                                                  • @public

                                                                                                call signature

                                                                                                <T>(
                                                                                                body: StreamType,
                                                                                                deserializer: (input: Record<string, Message>) => Promise<T>
                                                                                                ): AsyncIterable<T>;

                                                                                                  interface EventStreamMarshallerSerFn

                                                                                                  interface EventStreamMarshallerSerFn<StreamType> {}
                                                                                                  • A function that serializes modeled shape into binary stream message.

                                                                                                    Modifiers

                                                                                                    • @public

                                                                                                  call signature

                                                                                                  <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;

                                                                                                    interface EventStreamPayloadHandler

                                                                                                    interface EventStreamPayloadHandler {}
                                                                                                    • Modifiers

                                                                                                      • @public

                                                                                                    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 {}
                                                                                                      • Modifiers

                                                                                                        • @public

                                                                                                      call signature

                                                                                                      (options: any): EventStreamPayloadHandler;

                                                                                                        interface EventStreamRequestSigner

                                                                                                        interface EventStreamRequestSigner {}
                                                                                                        • Modifiers

                                                                                                          • @public

                                                                                                        method sign

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

                                                                                                          interface EventStreamSerdeContext

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

                                                                                                            Modifiers

                                                                                                            • @public

                                                                                                          property eventStreamMarshaller

                                                                                                          eventStreamMarshaller: EventStreamMarshaller;

                                                                                                            interface EventStreamSerdeProvider

                                                                                                            interface EventStreamSerdeProvider {}
                                                                                                            • Modifiers

                                                                                                              • @public

                                                                                                            call signature

                                                                                                            (options: any): EventStreamMarshaller;

                                                                                                              interface EventStreamSignerProvider

                                                                                                              interface EventStreamSignerProvider {}
                                                                                                              • Modifiers

                                                                                                                • @public

                                                                                                              call signature

                                                                                                              (options: any): EventStreamRequestSigner;

                                                                                                                interface ExponentialBackoffStrategyOptions

                                                                                                                interface ExponentialBackoffStrategyOptions {}
                                                                                                                • Modifiers

                                                                                                                  • @public

                                                                                                                property backoffScaleValue

                                                                                                                backoffScaleValue?: number;

                                                                                                                  property jitterType

                                                                                                                  jitterType: ExponentialBackoffJitterType;

                                                                                                                    interface FinalizeHandler

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

                                                                                                                      • @public

                                                                                                                    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> {}
                                                                                                                    • Modifiers

                                                                                                                      • @public

                                                                                                                    property request

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

                                                                                                                    interface FinalizeHandlerOutput

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

                                                                                                                      • @public

                                                                                                                    interface FinalizeRequestHandlerOptions

                                                                                                                    interface FinalizeRequestHandlerOptions extends HandlerOptions {}
                                                                                                                    • Modifiers

                                                                                                                      • @public

                                                                                                                    property step

                                                                                                                    step: 'finalizeRequest';

                                                                                                                      interface FinalizeRequestMiddleware

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

                                                                                                                        Modifiers

                                                                                                                        • @public

                                                                                                                      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 {}
                                                                                                                      • Modifiers

                                                                                                                        • @public

                                                                                                                      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.

                                                                                                                            Modifiers

                                                                                                                            • @public

                                                                                                                          call signature

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

                                                                                                                            interface GetAwsChunkedEncodingStreamOptions

                                                                                                                            interface GetAwsChunkedEncodingStreamOptions {}
                                                                                                                            • Modifiers

                                                                                                                              • @public

                                                                                                                            property base64Encoder

                                                                                                                            base64Encoder?: Encoder;

                                                                                                                              property bodyLengthChecker

                                                                                                                              bodyLengthChecker: BodyLengthCalculator;

                                                                                                                                property checksumAlgorithmFn

                                                                                                                                checksumAlgorithmFn?: ChecksumConstructor | 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.

                                                                                                                                        Modifiers

                                                                                                                                        • @public

                                                                                                                                      property authSchemes

                                                                                                                                      authSchemes?: AuthScheme[];
                                                                                                                                      • Set at the same time as endpointV2.

                                                                                                                                      property currentAuthConfig

                                                                                                                                      currentAuthConfig?: HttpAuthDefinition;
                                                                                                                                      • The current auth configuration that has been set by any auth middleware and that will prevent from being set more than once.

                                                                                                                                      property dynamoDbDocumentClientOptions

                                                                                                                                      dynamoDbDocumentClientOptions?: Partial<{
                                                                                                                                      overrideInputFilterSensitiveLog(...args: any[]): string | void;
                                                                                                                                      overrideOutputFilterSensitiveLog(...args: any[]): string | void;
                                                                                                                                      }>;
                                                                                                                                      • Used by DynamoDbDocumentClient.

                                                                                                                                      property endpointV2

                                                                                                                                      endpointV2?: EndpointV2;
                                                                                                                                      • Resolved by the endpointMiddleware function of @aws-sdk/middleware-endpoint in the serialization stage.

                                                                                                                                      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 {}
                                                                                                                                        • Modifiers

                                                                                                                                          • @public

                                                                                                                                        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.

                                                                                                                                        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.

                                                                                                                                          Modifiers

                                                                                                                                          • @public

                                                                                                                                          Deprecated

                                                                                                                                          use Checksum

                                                                                                                                        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.

                                                                                                                                          Modifiers

                                                                                                                                          • @public

                                                                                                                                          Deprecated

                                                                                                                                          use ChecksumConstructor

                                                                                                                                        construct signature

                                                                                                                                        new (secret?: SourceData): Hash;

                                                                                                                                          interface Headers

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

                                                                                                                                            Modifiers

                                                                                                                                            • @public

                                                                                                                                          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 HostAddress

                                                                                                                                          interface HostAddress {}
                                                                                                                                          • Modifiers

                                                                                                                                            • @public

                                                                                                                                          property address

                                                                                                                                          address: string;
                                                                                                                                          • The resolved numerical address represented as a string.

                                                                                                                                          property addressType

                                                                                                                                          addressType: HostAddressType;

                                                                                                                                          property hostName

                                                                                                                                          hostName: string;
                                                                                                                                          • The host name the address was resolved from.

                                                                                                                                          property service

                                                                                                                                          service?: string;

                                                                                                                                          interface HostResolver

                                                                                                                                          interface HostResolver {}
                                                                                                                                          • Host Resolver interface for DNS queries

                                                                                                                                            Modifiers

                                                                                                                                            • @public

                                                                                                                                          method purgeCache

                                                                                                                                          purgeCache: (args?: HostResolverArguments) => void;

                                                                                                                                          method reportFailureOnAddress

                                                                                                                                          reportFailureOnAddress: (addr: HostAddress) => void;
                                                                                                                                          • Reports a failure on a HostAddress so that the cache (if implemented) can accomodate the failure and likely not return the address until it recovers.

                                                                                                                                            Parameter addr

                                                                                                                                            host address to report a failure on

                                                                                                                                          method resolveAddress

                                                                                                                                          resolveAddress: (args: HostResolverArguments) => Promise<HostAddress[]>;
                                                                                                                                          • Resolves the address(es) for HostResolverArguments and returns a list of addresses with (most likely) two addresses, one HostAddressType.AAAA and one HostAddressType.A. Calls to this function will likely alter the cache (if implemented) so that if there's multiple addresses, a different set will be returned on the next call. In the case of multi-answer, still only a maximum of two records should be returned. The resolver implementation is responsible for caching and rotation of the multiple addresses that get returned. Implementations don't have to explictly call getaddrinfo(), they can use high level abstractions provided in their language runtimes/libraries.

                                                                                                                                            Parameter args

                                                                                                                                            arguments with host name query addresses for

                                                                                                                                            Returns

                                                                                                                                            promise with a list of HostAddress

                                                                                                                                          interface HostResolverArguments

                                                                                                                                          interface HostResolverArguments {}
                                                                                                                                          • Modifiers

                                                                                                                                            • @public

                                                                                                                                          property hostName

                                                                                                                                          hostName: string;
                                                                                                                                          • The host name to resolve.

                                                                                                                                          property service

                                                                                                                                          service?: string;

                                                                                                                                          interface HttpHandlerOptions

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

                                                                                                                                            Modifiers

                                                                                                                                            • @public

                                                                                                                                          property abortSignal

                                                                                                                                          abortSignal?: AbortSignal;

                                                                                                                                            property requestTimeout

                                                                                                                                            requestTimeout?: number;
                                                                                                                                            • The maximum time in milliseconds that the connection phase of a request may take before the connection attempt is abandoned.

                                                                                                                                            interface HttpMessage

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

                                                                                                                                              Modifiers

                                                                                                                                              • @public

                                                                                                                                            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.

                                                                                                                                                  Modifiers

                                                                                                                                                  • @public

                                                                                                                                                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.

                                                                                                                                                    Modifiers

                                                                                                                                                    • @public

                                                                                                                                                  property statusCode

                                                                                                                                                  statusCode: number;

                                                                                                                                                    interface Identity

                                                                                                                                                    interface Identity {}
                                                                                                                                                    • Modifiers

                                                                                                                                                      • @public

                                                                                                                                                    property expiration

                                                                                                                                                    readonly expiration?: Date;
                                                                                                                                                    • A Date when the identity or credential will no longer be accepted.

                                                                                                                                                    interface IdentityProvider

                                                                                                                                                    interface IdentityProvider<IdentityT extends Identity> {}
                                                                                                                                                    • Modifiers

                                                                                                                                                      • @public

                                                                                                                                                    call signature

                                                                                                                                                    (identityProperties?: Record<string, any>): Promise<IdentityT>;

                                                                                                                                                      interface InitializeHandler

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

                                                                                                                                                        • @public

                                                                                                                                                      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> {}
                                                                                                                                                      • Modifiers

                                                                                                                                                        • @public

                                                                                                                                                      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 {}
                                                                                                                                                      • Modifiers

                                                                                                                                                        • @public

                                                                                                                                                      property step

                                                                                                                                                      step?: 'initialize';

                                                                                                                                                        interface InitializeHandlerOutput

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

                                                                                                                                                          • @public

                                                                                                                                                        property output

                                                                                                                                                        output: Output;

                                                                                                                                                          interface InitializeMiddleware

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

                                                                                                                                                            Modifiers

                                                                                                                                                            • @public

                                                                                                                                                          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 {}
                                                                                                                                                          • Modifiers

                                                                                                                                                            • @public

                                                                                                                                                          property bytes

                                                                                                                                                          readonly bytes: Uint8Array;

                                                                                                                                                            property toString

                                                                                                                                                            toString: () => string;

                                                                                                                                                              property valueOf

                                                                                                                                                              valueOf: () => number;

                                                                                                                                                                interface IntegerHeaderValue

                                                                                                                                                                interface IntegerHeaderValue {}
                                                                                                                                                                • Modifiers

                                                                                                                                                                  • @public

                                                                                                                                                                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.

                                                                                                                                                                      Modifiers

                                                                                                                                                                      • @public

                                                                                                                                                                    property debug

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

                                                                                                                                                                      property error

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

                                                                                                                                                                        property info

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

                                                                                                                                                                          property trace

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

                                                                                                                                                                            property warn

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

                                                                                                                                                                              interface LoggerOptions

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

                                                                                                                                                                                Modifiers

                                                                                                                                                                                • @public

                                                                                                                                                                              property logger

                                                                                                                                                                              logger?: Logger;

                                                                                                                                                                                property logLevel

                                                                                                                                                                                logLevel?: LogLevel;

                                                                                                                                                                                  interface LoginIdentity

                                                                                                                                                                                  interface LoginIdentity extends Identity {}
                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                    • @public

                                                                                                                                                                                  property password

                                                                                                                                                                                  readonly password: string;
                                                                                                                                                                                  • Identity password

                                                                                                                                                                                  property username

                                                                                                                                                                                  readonly username: string;
                                                                                                                                                                                  • Identity username

                                                                                                                                                                                  interface LongHeaderValue

                                                                                                                                                                                  interface LongHeaderValue {}
                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                    • @public

                                                                                                                                                                                  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.

                                                                                                                                                                                        Modifiers

                                                                                                                                                                                        • @public

                                                                                                                                                                                      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.

                                                                                                                                                                                          Modifiers

                                                                                                                                                                                          • @public

                                                                                                                                                                                        property body

                                                                                                                                                                                        body: Uint8Array;

                                                                                                                                                                                          property headers

                                                                                                                                                                                          headers: MessageHeaders;

                                                                                                                                                                                            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.

                                                                                                                                                                                              Modifiers

                                                                                                                                                                                              • @public

                                                                                                                                                                                            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 identify

                                                                                                                                                                                            identify: () => string[];
                                                                                                                                                                                            • Returns a list of the current order of middleware in the stack. This does not execute the middleware functions, nor does it provide a reference to the stack itself.

                                                                                                                                                                                            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.

                                                                                                                                                                                              Modifiers

                                                                                                                                                                                              • @public

                                                                                                                                                                                            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 Pluggable

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

                                                                                                                                                                                                    • @public

                                                                                                                                                                                                  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 extends IniSection {}

                                                                                                                                                                                                  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.

                                                                                                                                                                                                    Modifiers

                                                                                                                                                                                                    • @public

                                                                                                                                                                                                  call signature

                                                                                                                                                                                                  (): Promise<T>;

                                                                                                                                                                                                    interface randomValues

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

                                                                                                                                                                                                      Modifiers

                                                                                                                                                                                                      • @public

                                                                                                                                                                                                    call signature

                                                                                                                                                                                                    (byteLength: number): Promise<Uint8Array>;

                                                                                                                                                                                                      interface RegionInfo

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

                                                                                                                                                                                                        Modifiers

                                                                                                                                                                                                        • @public

                                                                                                                                                                                                      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

                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                call signature

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

                                                                                                                                                                                                                  interface RegionInfoProviderOptions

                                                                                                                                                                                                                  interface RegionInfoProviderOptions {}

                                                                                                                                                                                                                  property useDualstackEndpoint

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

                                                                                                                                                                                                                  property useFipsEndpoint

                                                                                                                                                                                                                  useFipsEndpoint: boolean;
                                                                                                                                                                                                                  • Enables FIPS compatible endpoints.

                                                                                                                                                                                                                  interface RelativeLocation

                                                                                                                                                                                                                  interface RelativeLocation {}
                                                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                  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 RequestContext

                                                                                                                                                                                                                  interface RequestContext {}

                                                                                                                                                                                                                    property destination

                                                                                                                                                                                                                    destination: URL;

                                                                                                                                                                                                                      interface RequestHandler

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

                                                                                                                                                                                                                        • @public

                                                                                                                                                                                                                      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 {}
                                                                                                                                                                                                                          • Modifiers

                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                          property handlerProtocol

                                                                                                                                                                                                                          handlerProtocol: RequestHandlerProtocol | string;

                                                                                                                                                                                                                            interface RequestPresigner

                                                                                                                                                                                                                            interface RequestPresigner {}
                                                                                                                                                                                                                            • Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            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 {}
                                                                                                                                                                                                                            • Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            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> {}
                                                                                                                                                                                                                            • Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            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.

                                                                                                                                                                                                                              Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            method sign

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

                                                                                                                                                                                                                            interface RequestSigningArguments

                                                                                                                                                                                                                            interface RequestSigningArguments extends SigningArguments {}
                                                                                                                                                                                                                            • Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            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.

                                                                                                                                                                                                                              Modifiers

                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                            property body

                                                                                                                                                                                                                            body: string;

                                                                                                                                                                                                                              interface ResponseDeserializer

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

                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                              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 RetryableTrait

                                                                                                                                                                                                                              interface RetryableTrait {}
                                                                                                                                                                                                                              • A structure shape with the error trait. https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait

                                                                                                                                                                                                                                Modifiers

                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                              property throttling

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

                                                                                                                                                                                                                              interface RetryBackoffStrategy

                                                                                                                                                                                                                              interface RetryBackoffStrategy {}
                                                                                                                                                                                                                              • Modifiers

                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                              method computeNextBackoffDelay

                                                                                                                                                                                                                              computeNextBackoffDelay: (retryAttempt: number) => number;
                                                                                                                                                                                                                              • Returns

                                                                                                                                                                                                                                the number of milliseconds to wait before retrying an action.

                                                                                                                                                                                                                              interface RetryErrorInfo

                                                                                                                                                                                                                              interface RetryErrorInfo {}
                                                                                                                                                                                                                              • Modifiers

                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                              property errorType

                                                                                                                                                                                                                              errorType: RetryErrorType;

                                                                                                                                                                                                                                property retryAfterHint

                                                                                                                                                                                                                                retryAfterHint?: Date;
                                                                                                                                                                                                                                • Protocol hint. This could come from Http's 'retry-after' header or something from MQTT or any other protocol that has the ability to convey retry info from a peer.

                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                  the Date after which a retry should be attempted.

                                                                                                                                                                                                                                interface RetryStrategy

                                                                                                                                                                                                                                interface RetryStrategy {}
                                                                                                                                                                                                                                • Interface that specifies the retry behavior

                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                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 RetryStrategyOptions

                                                                                                                                                                                                                                interface RetryStrategyOptions {}
                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                property backoffStrategy

                                                                                                                                                                                                                                backoffStrategy: RetryBackoffStrategy;

                                                                                                                                                                                                                                  property maxRetriesBase

                                                                                                                                                                                                                                  maxRetriesBase: number;

                                                                                                                                                                                                                                    interface RetryStrategyV2

                                                                                                                                                                                                                                    interface RetryStrategyV2 {}
                                                                                                                                                                                                                                    • Modifiers

                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                    method acquireInitialRetryToken

                                                                                                                                                                                                                                    acquireInitialRetryToken: (retryTokenScope: string) => Promise<RetryToken>;
                                                                                                                                                                                                                                    • Called before any retries (for the first call to the operation). It either returns a retry token or an error upon the failure to acquire a token prior.

                                                                                                                                                                                                                                      tokenScope is arbitrary and out of scope for this component. However, adding it here offers us a lot of future flexibility for outage detection. For example, it could be "us-east-1" on a shared retry strategy, or "us-west-2-c:dynamodb".

                                                                                                                                                                                                                                    method recordSuccess

                                                                                                                                                                                                                                    recordSuccess: (token: RetryToken) => void;
                                                                                                                                                                                                                                    • Upon successful completion of the operation, a user calls this function to record that the operation was successful.

                                                                                                                                                                                                                                    method refreshRetryTokenForRetry

                                                                                                                                                                                                                                    refreshRetryTokenForRetry: (
                                                                                                                                                                                                                                    tokenToRenew: RetryToken,
                                                                                                                                                                                                                                    errorInfo: RetryErrorInfo
                                                                                                                                                                                                                                    ) => Promise<RetryToken>;
                                                                                                                                                                                                                                    • After a failed operation call, this function is invoked to refresh the retryToken returned by acquireInitialRetryToken(). This function can either choose to allow another retry and send a new or updated token, or reject the retry attempt and report the error either in an exception or returning an error.

                                                                                                                                                                                                                                    interface RetryToken

                                                                                                                                                                                                                                    interface RetryToken {}
                                                                                                                                                                                                                                    • Modifiers

                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                    method getRetryCount

                                                                                                                                                                                                                                    getRetryCount: () => number;
                                                                                                                                                                                                                                    • Returns

                                                                                                                                                                                                                                      the current count of retry.

                                                                                                                                                                                                                                    method getRetryDelay

                                                                                                                                                                                                                                    getRetryDelay: () => number;
                                                                                                                                                                                                                                    • Returns

                                                                                                                                                                                                                                      the number of milliseconds to wait before retrying an action.

                                                                                                                                                                                                                                    interface SdkStreamMixin

                                                                                                                                                                                                                                    interface SdkStreamMixin {}
                                                                                                                                                                                                                                    • The interface contains mix-in utility functions to transfer the runtime-specific stream implementation to specified format. Each stream can ONLY be transformed once.

                                                                                                                                                                                                                                    property transformToByteArray

                                                                                                                                                                                                                                    transformToByteArray: () => Promise<Uint8Array>;

                                                                                                                                                                                                                                      property transformToString

                                                                                                                                                                                                                                      transformToString: (encoding?: string) => Promise<string>;

                                                                                                                                                                                                                                        property transformToWebStream

                                                                                                                                                                                                                                        transformToWebStream: () => ReadableStream;

                                                                                                                                                                                                                                          interface SerdeContext

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

                                                                                                                                                                                                                                            Modifiers

                                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                                          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> {}
                                                                                                                                                                                                                                                        • Modifiers

                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                        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> {}
                                                                                                                                                                                                                                                        • Modifiers

                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                        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 {}
                                                                                                                                                                                                                                                        • Modifiers

                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                        property step

                                                                                                                                                                                                                                                        step: 'serialize';

                                                                                                                                                                                                                                                          interface SerializeHandlerOutput

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

                                                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                                                          interface SerializeMiddleware

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

                                                                                                                                                                                                                                                            Modifiers

                                                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                                                          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 {}
                                                                                                                                                                                                                                                          • Modifiers

                                                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                                                          property configFile

                                                                                                                                                                                                                                                          configFile: ParsedIniData;

                                                                                                                                                                                                                                                            property credentialsFile

                                                                                                                                                                                                                                                            credentialsFile: ParsedIniData;

                                                                                                                                                                                                                                                              interface ShortHeaderValue

                                                                                                                                                                                                                                                              interface ShortHeaderValue {}
                                                                                                                                                                                                                                                              • Modifiers

                                                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                              type: 'short';

                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                value: number;

                                                                                                                                                                                                                                                                  interface SigningArguments

                                                                                                                                                                                                                                                                  interface SigningArguments {}
                                                                                                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                                                                    Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                    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 StandardRetryBackoffStrategy

                                                                                                                                                                                                                                                                  interface StandardRetryBackoffStrategy extends RetryBackoffStrategy {}
                                                                                                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                  method setDelayBase

                                                                                                                                                                                                                                                                  setDelayBase: (delayBase: number) => void;
                                                                                                                                                                                                                                                                  • Sets the delayBase used to compute backoff delays.

                                                                                                                                                                                                                                                                    Parameter delayBase

                                                                                                                                                                                                                                                                  interface StandardRetryToken

                                                                                                                                                                                                                                                                  interface StandardRetryToken extends RetryToken {}
                                                                                                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                  method getLastRetryCost

                                                                                                                                                                                                                                                                  getLastRetryCost: () => number | undefined;
                                                                                                                                                                                                                                                                  • Returns

                                                                                                                                                                                                                                                                    the cost of the last retry attemp.

                                                                                                                                                                                                                                                                  method getRetryTokenCount

                                                                                                                                                                                                                                                                  getRetryTokenCount: (errorInfo: RetryErrorInfo) => number;
                                                                                                                                                                                                                                                                  • Returns

                                                                                                                                                                                                                                                                    the number of available tokens.

                                                                                                                                                                                                                                                                  method hasRetryTokens

                                                                                                                                                                                                                                                                  hasRetryTokens: (errorType: RetryErrorType) => boolean;
                                                                                                                                                                                                                                                                  • Returns

                                                                                                                                                                                                                                                                    wheather token has remaining tokens.

                                                                                                                                                                                                                                                                  method releaseRetryTokens

                                                                                                                                                                                                                                                                  releaseRetryTokens: (amount?: number) => void;
                                                                                                                                                                                                                                                                  • Releases a number of tokens.

                                                                                                                                                                                                                                                                    Parameter amount

                                                                                                                                                                                                                                                                    of tokens to release.

                                                                                                                                                                                                                                                                  interface StreamCollector

                                                                                                                                                                                                                                                                  interface StreamCollector {}
                                                                                                                                                                                                                                                                  • Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                                                                    Modifiers

                                                                                                                                                                                                                                                                    • @public

                                                                                                                                                                                                                                                                  call signature

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

                                                                                                                                                                                                                                                                    interface StringHeaderValue

                                                                                                                                                                                                                                                                    interface StringHeaderValue {}
                                                                                                                                                                                                                                                                    • Modifiers

                                                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                    type: 'string';

                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                        interface StringSigner

                                                                                                                                                                                                                                                                        interface StringSigner {}
                                                                                                                                                                                                                                                                        • Modifiers

                                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                                        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.

                                                                                                                                                                                                                                                                          Modifiers

                                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                          interface TimestampHeaderValue

                                                                                                                                                                                                                                                                          interface TimestampHeaderValue {}
                                                                                                                                                                                                                                                                          • Modifiers

                                                                                                                                                                                                                                                                            • @public

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: 'timestamp';

                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                            value: Date;

                                                                                                                                                                                                                                                                              interface Token

                                                                                                                                                                                                                                                                              interface Token extends TokenIdentity {}
                                                                                                                                                                                                                                                                              • An object representing temporary or permanent AWS token.

                                                                                                                                                                                                                                                                                Modifiers

                                                                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                Use TokenIdentity

                                                                                                                                                                                                                                                                              interface TokenIdentity

                                                                                                                                                                                                                                                                              interface TokenIdentity extends Identity {}
                                                                                                                                                                                                                                                                              • Modifiers

                                                                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                                                                              property token

                                                                                                                                                                                                                                                                              readonly token: string;
                                                                                                                                                                                                                                                                              • The literal token string

                                                                                                                                                                                                                                                                              interface UrlParser

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

                                                                                                                                                                                                                                                                                Modifiers

                                                                                                                                                                                                                                                                                • @public

                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                              (url: string | URL): Endpoint;

                                                                                                                                                                                                                                                                                interface UuidHeaderValue

                                                                                                                                                                                                                                                                                interface UuidHeaderValue {}
                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                type: 'uuid';

                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                  value: string;

                                                                                                                                                                                                                                                                                    interface WaiterConfiguration

                                                                                                                                                                                                                                                                                    interface WaiterConfiguration<Client> {}
                                                                                                                                                                                                                                                                                    • Modifiers

                                                                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                    Enums

                                                                                                                                                                                                                                                                                    enum EndpointURLScheme

                                                                                                                                                                                                                                                                                    enum EndpointURLScheme {
                                                                                                                                                                                                                                                                                    HTTP = 'http',
                                                                                                                                                                                                                                                                                    HTTPS = 'https',
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                    • Modifiers

                                                                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                                                                    member HTTP

                                                                                                                                                                                                                                                                                    HTTP = 'http'

                                                                                                                                                                                                                                                                                      member HTTPS

                                                                                                                                                                                                                                                                                      HTTPS = 'https'

                                                                                                                                                                                                                                                                                        enum HostAddressType

                                                                                                                                                                                                                                                                                        enum HostAddressType {
                                                                                                                                                                                                                                                                                        AAAA = 'AAAA',
                                                                                                                                                                                                                                                                                        A = 'A',
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                        • DNS record types

                                                                                                                                                                                                                                                                                          Modifiers

                                                                                                                                                                                                                                                                                          • @public

                                                                                                                                                                                                                                                                                        member A

                                                                                                                                                                                                                                                                                        A = 'A'
                                                                                                                                                                                                                                                                                        • IPv4

                                                                                                                                                                                                                                                                                        member AAAA

                                                                                                                                                                                                                                                                                        AAAA = 'AAAA'
                                                                                                                                                                                                                                                                                        • IPv6

                                                                                                                                                                                                                                                                                        enum RequestHandlerProtocol

                                                                                                                                                                                                                                                                                        enum RequestHandlerProtocol {
                                                                                                                                                                                                                                                                                        HTTP_0_9 = 'http/0.9',
                                                                                                                                                                                                                                                                                        HTTP_1_0 = 'http/1.0',
                                                                                                                                                                                                                                                                                        TDS_8_0 = 'tds/8.0',
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          member HTTP_0_9

                                                                                                                                                                                                                                                                                          HTTP_0_9 = 'http/0.9'

                                                                                                                                                                                                                                                                                            member HTTP_1_0

                                                                                                                                                                                                                                                                                            HTTP_1_0 = 'http/1.0'

                                                                                                                                                                                                                                                                                              member TDS_8_0

                                                                                                                                                                                                                                                                                              TDS_8_0 = 'tds/8.0'

                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                type AwsCredentialIdentityProvider

                                                                                                                                                                                                                                                                                                type AwsCredentialIdentityProvider = IdentityProvider<AwsCredentialIdentity>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type EndpointObjectProperty

                                                                                                                                                                                                                                                                                                type EndpointObjectProperty =
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                [key: string]: EndpointObjectProperty;
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                | EndpointObjectProperty[];
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type EndpointParameters

                                                                                                                                                                                                                                                                                                type EndpointParameters = {
                                                                                                                                                                                                                                                                                                [name: string]: undefined | string | boolean;
                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type ExponentialBackoffJitterType

                                                                                                                                                                                                                                                                                                type ExponentialBackoffJitterType = 'DEFAULT' | 'NONE' | 'FULL' | 'DECORRELATED';
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type Handler

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type HeaderBag

                                                                                                                                                                                                                                                                                                type HeaderBag = Record<string, string>;
                                                                                                                                                                                                                                                                                                • 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.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type IniSection

                                                                                                                                                                                                                                                                                                type IniSection = Record<string, string | undefined>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type LoginIdentityProvider

                                                                                                                                                                                                                                                                                                type LoginIdentityProvider = IdentityProvider<LoginIdentity>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type LogLevel

                                                                                                                                                                                                                                                                                                type LogLevel =
                                                                                                                                                                                                                                                                                                | 'all'
                                                                                                                                                                                                                                                                                                | 'trace'
                                                                                                                                                                                                                                                                                                | 'debug'
                                                                                                                                                                                                                                                                                                | '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.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type MessageHeaders

                                                                                                                                                                                                                                                                                                type MessageHeaders = Record<string, MessageHeaderValue>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type MessageHeaderValue

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                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>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type Paginator

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

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type ParsedIniData

                                                                                                                                                                                                                                                                                                type ParsedIniData = Record<string, IniSection>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type Priority

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type QueryParameterBag

                                                                                                                                                                                                                                                                                                type QueryParameterBag = Record<string, string | Array<string> | null>;
                                                                                                                                                                                                                                                                                                • 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

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type Relation

                                                                                                                                                                                                                                                                                                type Relation = 'before' | 'after';
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type RelativeMiddlewareOptions

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type RequestHandlerOutput

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type RetryErrorType

                                                                                                                                                                                                                                                                                                type RetryErrorType =
                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                * This is a connection level error such as a socket timeout, socket connect
                                                                                                                                                                                                                                                                                                * error, tls negotiation timeout etc...
                                                                                                                                                                                                                                                                                                * Typically these should never be applied for non-idempotent request types
                                                                                                                                                                                                                                                                                                * since in this scenario, it's impossible to know whether the operation had
                                                                                                                                                                                                                                                                                                * a side effect on the server.
                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                | 'TRANSIENT'
                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                * This is an error where the server explicitly told the client to back off,
                                                                                                                                                                                                                                                                                                * such as a 429 or 503 Http error.
                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                | 'THROTTLING'
                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                * This is a server error that isn't explicitly throttling but is considered
                                                                                                                                                                                                                                                                                                * by the client to be something that should be retried.
                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                | 'SERVER_ERROR'
                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                * Doesn't count against any budgets. This could be something like a 401
                                                                                                                                                                                                                                                                                                * challenge in Http.
                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                | 'CLIENT_ERROR';
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type SdkError

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                  See https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/

                                                                                                                                                                                                                                                                                                  This type should not be used in your application. Users of the AWS SDK for JavaScript v3 service clients should prefer to use the specific Exception classes corresponding to each operation. These can be found as code in the deserializer for the operation's Command class, or as declarations in the service model file in codegen/sdk-codegen/aws-models.

                                                                                                                                                                                                                                                                                                  If no exceptions are enumerated by a particular Command operation, the base exception for the service should be used. Each client exports a base ServiceException prefixed with the service name.

                                                                                                                                                                                                                                                                                                type SdkStream

                                                                                                                                                                                                                                                                                                type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
                                                                                                                                                                                                                                                                                                • The type describing a runtime-specific stream implementation with mix-in utility functions.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type SourceData

                                                                                                                                                                                                                                                                                                type SourceData = string | ArrayBuffer | ArrayBufferView;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type Step

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

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type TokenIdentityProvider

                                                                                                                                                                                                                                                                                                type TokenIdentityProvider = IdentityProvider<TokenIdentity>;
                                                                                                                                                                                                                                                                                                • Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type TokenProvider

                                                                                                                                                                                                                                                                                                type TokenProvider = Provider<Token>;

                                                                                                                                                                                                                                                                                                type UserAgent

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

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                type WithSdkStreamMixin

                                                                                                                                                                                                                                                                                                type WithSdkStreamMixin<T, StreamKey extends keyof T> = {
                                                                                                                                                                                                                                                                                                [key in keyof T]: key extends StreamKey ? SdkStream<T[StreamKey]> : T[key];
                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                • Indicates that the member of type T with key StreamKey have been extended with the SdkStreamMixin helper methods.

                                                                                                                                                                                                                                                                                                  Modifiers

                                                                                                                                                                                                                                                                                                  • @public

                                                                                                                                                                                                                                                                                                Package Files (29)

                                                                                                                                                                                                                                                                                                Dependencies (1)

                                                                                                                                                                                                                                                                                                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>