@aws-sdk/types

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.

call signature

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

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.

property priority

priority?: Priority;

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

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.

property type

type: 'binary';

property value

value: Uint8Array;

call signature

(body: any): number | undefined;

property type

type: 'boolean';

property value

value: boolean;

call signature

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

property step

step: 'build';

call signature

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

property type

type: 'byte';

property value

value: number;

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.

construct signature

new (secret?: SourceData): Checksum;

property config

readonly config: ResolvedClientConfiguration;

property destroy

destroy: () => void;

property middlewareStack

middlewareStack: MiddlewareStack<Input, Output>;

property send

send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;

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

call signature

(input: string): Uint8Array;

call signature

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

property step

step: 'deserialize';

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

call signature

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

call signature

(input: Uint8Array): string;

property hostname

hostname: string;

property path

path: string;

property port

port?: number;

property protocol

protocol: string;

property query

query?: QueryParameterBag;

property accountId

accountId: string;

property partition

partition: string;

property region

region: string;

property resourceId

resourceId: Array<string>;

property service

service: string;

property endpoint

endpoint: Provider<Endpoint>;

property dnsSuffix

dnsSuffix: string;

property dualStackDnsSuffix

dualStackDnsSuffix: string;

property name

name: string;

property supportsDualStack

supportsDualStack: boolean;

property supportsFIPS

supportsFIPS: boolean;

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.

property headers

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

property properties

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

property url

url: URL;

method sign

sign: (event: FormattedEvent, options: EventSigningArguments) => Promise<string>;

• Sign the individual event of the event stream.

property priorSignature

priorSignature: string;

property deserialize

deserialize: EventStreamMarshallerDeserFn<StreamType>;

property serialize

serialize: EventStreamMarshallerSerFn<StreamType>;

call signature

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

call signature

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

property handle

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

call signature

(options: any): EventStreamPayloadHandler;

method sign

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

property eventStreamMarshaller

eventStreamMarshaller: EventStreamMarshaller;

call signature

(options: any): EventStreamMarshaller;

call signature

(options: any): EventStreamRequestSigner;

property backoffScaleValue

backoffScaleValue?: number;

property jitterType

jitterType: ExponentialBackoffJitterType;

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.

property request

request: unknown;

• The user input serialized as a request.

property step

step: 'finalizeRequest';

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.

property headers

headers: Uint8Array;

property payload

payload: Uint8Array;

call signature

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

property base64Encoder

base64Encoder?: Encoder;

property bodyLengthChecker

bodyLengthChecker: BodyLengthCalculator;

property checksumAlgorithmFn

checksumAlgorithmFn?: ChecksumConstructor | HashConstructor;

property checksumLocationName

checksumLocationName?: string;

property streamHasher

streamHasher?: StreamHasher;

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;

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.

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.

construct signature

new (secret?: SourceData): Hash;

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

property address

address: string;

• The resolved numerical address represented as a string.

property addressType

addressType: HostAddressType;

• The HostAddressType of the host address.

property hostName

hostName: string;

• The host name the address was resolved from.

property service

service?: string;

• The service record of hostName.

method purgeCache

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

• Empties the cache (if implemented) for a HostResolverArguments.hostName. If HostResolverArguments.hostName is not provided, the cache (if implemented) is emptied for all host names.

  Parameter args

  optional arguments to empty the cache for

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

property hostName

hostName: string;

• The host name to resolve.

property service

service?: string;

• The service record of hostName.

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.

property body

body?: any;

property headers

headers: HeaderBag;

property method

method: string;

property statusCode

statusCode: number;

property expiration

readonly expiration?: Date;

• A Date when the identity or credential will no longer be accepted.

call signature

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

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.

property input

input: Input;

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

property step

step?: 'initialize';

property output

output: Output;

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.

property bytes

readonly bytes: Uint8Array;

property toString

toString: () => string;

property valueOf

valueOf: () => number;

property type

type: 'integer';

property value

value: number;

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;

property logger

logger?: Logger;

property logLevel

logLevel?: LogLevel;

property password

readonly password: string;

• Identity password

property username

readonly username: string;

• Identity username

property type

type: 'long';

property value

value: Int64;

call signature

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

property body

body: Uint8Array;

property headers

headers: MessageHeaders;

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.