@aws-sdk/types 3.36.0 → 3.46.0

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.46.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.45.0...v3.46.0) (2022-01-07)
+
+
+### Bug Fixes
+
+* **middleware-signing:** correct clock skew from error response ([#3133](https://github.com/aws/aws-sdk-js-v3/issues/3133)) ([7a207a9](https://github.com/aws/aws-sdk-js-v3/commit/7a207a9d3173631f62f8b90ee1fbd7f68342133a))
+
+
+### Features
+
+* **packages:** end support for Node.js 10.x ([#3141](https://github.com/aws/aws-sdk-js-v3/issues/3141)) ([1a62865](https://github.com/aws/aws-sdk-js-v3/commit/1a6286513f7cdb556708845c512861c5f92eb883))
+
+
+
+
+
+# [3.40.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.39.0...v3.40.0) (2021-11-05)
+
+**Note:** Version bump only for package @aws-sdk/types
+
+
+
+
+
+# [3.38.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.37.0...v3.38.0) (2021-10-22)
+
+**Note:** Version bump only for package @aws-sdk/types
+
+
+
+
+
+# [3.37.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.1...v3.37.0) (2021-10-15)
+
+**Note:** Version bump only for package @aws-sdk/types
+
+
+
+
+
 # [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
 
 

package/dist-cjs/index.js

@@ -9,10 +9,10 @@ tslib_1.__exportStar(require("./crypto"), exports);
 tslib_1.__exportStar(require("./eventStream"), exports);
 tslib_1.__exportStar(require("./http"), exports);
 tslib_1.__exportStar(require("./logger"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./serde"), exports);
 tslib_1.__exportStar(require("./middleware"), exports);
+tslib_1.__exportStar(require("./pagination"), exports);
 tslib_1.__exportStar(require("./response"), exports);
+tslib_1.__exportStar(require("./serde"), exports);
 tslib_1.__exportStar(require("./shapes"), exports);
 tslib_1.__exportStar(require("./signature"), exports);
 tslib_1.__exportStar(require("./transfer"), exports);

package/dist-es/index.js

@@ -6,10 +6,10 @@ export * from "./crypto";
 export * from "./eventStream";
 export * from "./http";
 export * from "./logger";
-export * from "./pagination";
-export * from "./serde";
 export * from "./middleware";
+export * from "./pagination";
 export * from "./response";
+export * from "./serde";
 export * from "./shapes";
 export * from "./signature";
 export * from "./transfer";

package/dist-types/index.d.ts

@@ -6,10 +6,10 @@ export * from "./crypto";
 export * from "./eventStream";
 export * from "./http";
 export * from "./logger";
-export * from "./pagination";
-export * from "./serde";
 export * from "./middleware";
+export * from "./pagination";
 export * from "./response";
+export * from "./serde";
 export * from "./shapes";
 export * from "./signature";
 export * from "./transfer";

package/dist-types/shapes.d.ts

@@ -1,3 +1,4 @@
+import { HttpResponse } from "./http";
 import { MetadataBearer } from "./response";
 /**
  * A document type represents an untyped JSON-like value.
@@ -41,5 +42,9 @@ export interface SmithyException {
      * Indicates that an error MAY be retried by the client.
      */
     readonly $retryable?: RetryableTrait;
+    /**
+     * Reference to low-level HTTP response object.
+     */
+    readonly $response?: HttpResponse;
 }
 export declare type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;

package/dist-types/ts3.4/abort.d.ts

@@ -1,42 +1,17 @@
 export interface AbortHandler {
     (this: AbortSignal, ev: any): any;
 }
-/**
- * Holders of an AbortSignal object may query if the associated operation has
- * been aborted and register an onabort handler.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
- */
+
 export interface AbortSignal {
-    /**
-     * Whether the action represented by this signal has been cancelled.
-     */
+    
     readonly aborted: boolean;
-    /**
-     * A function to be invoked when the action represented by this signal has
-     * been cancelled.
-     */
+    
     onabort: AbortHandler | null;
 }
-/**
- * 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 https://developer.mozilla.org/en-US/docs/Web/API/AbortController
- */
+
 export interface AbortController {
-    /**
-     * An object that reports whether the action associated with this
-     * {AbortController} has been cancelled.
-     */
+    
     readonly signal: AbortSignal;
-    /**
-     * Declares the operation associated with this AbortController to have been
-     * cancelled.
-     */
+    
     abort(): void;
 }

package/dist-types/ts3.4/client.d.ts

@@ -1,19 +1,13 @@
 import { Command } from "./command";
 import { MiddlewareStack } from "./middleware";
 import { MetadataBearer } from "./response";
-/**
- * function definition for different overrides of client's 'send' function.
- */
+
 interface InvokeFunction<InputTypes extends object, OutputTypes extends MetadataBearer, ResolvedClientConfiguration> {
     <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any): Promise<OutputType>;
     <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options: any, cb: (err: any, data?: OutputType) => void): void;
     <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
 }
-/**
- * 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.
- */
+
 export interface Client<Input extends object, Output extends MetadataBearer, ResolvedClientConfiguration> {
     readonly config: ResolvedClientConfiguration;
     middlewareStack: MiddlewareStack<Input, Output>;

package/dist-types/ts3.4/credentials.d.ts

@@ -1,24 +1,13 @@
 import { Provider } from "./util";
-/**
- * An object representing temporary or permanent AWS credentials.
- */
+
 export interface Credentials {
-    /**
-     * AWS access key ID
-     */
+    
     readonly accessKeyId: string;
-    /**
-     * AWS secret access key
-     */
+    
     readonly secretAccessKey: string;
-    /**
-     * A security or session token to use with these credentials. Usually
-     * present for temporary credentials.
-     */
+    
     readonly sessionToken?: string;
-    /**
-     * A {Date} when these credentials will no longer be accepted.
-     */
+    
     readonly expiration?: Date;
 }
 export declare type CredentialProvider = Provider<Credentials>;

package/dist-types/ts3.4/crypto.d.ts

@@ -1,45 +1,20 @@
 export declare type SourceData = string | ArrayBuffer | ArrayBufferView;
-/**
- * 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.
- */
+
 export interface Hash {
-    /**
-     * 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.
-     */
+    
     update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
-    /**
-     * Finalizes the hash and provides a promise that will be fulfilled with the
-     * raw bytes of the calculated hash.
-     */
+    
     digest(): Promise<Uint8Array>;
 }
-/**
- * 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.
- */
+
 export interface HashConstructor {
     new (secret?: SourceData): Hash;
 }
-/**
- * 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.
- */
+
 export interface StreamHasher<StreamType = any> {
     (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
 }
-/**
- * A function that returns a promise fulfilled with bytes from a
- * cryptographically secure pseudorandom number generator.
- */
+
 export interface randomValues {
     (byteLength: number): Promise<Uint8Array>;
 }

package/dist-types/ts3.4/eventStream.d.ts

@@ -1,11 +1,7 @@
 import { HttpRequest } from "./http";
 import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext } from "./middleware";
 import { MetadataBearer } from "./response";
-/**
- * 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.
- */
+
 export interface Message {
     headers: MessageHeaders;
     body: Uint8Array;
@@ -55,9 +51,7 @@ export interface Int64 {
     valueOf: () => number;
     toString: () => string;
 }
-/**
- * Util functions for serializing or deserializing event stream
- */
+
 export interface EventStreamSerdeContext {
     eventStreamMarshaller: EventStreamMarshaller;
 }

package/dist-types/ts3.4/http.d.ts

@@ -1,58 +1,21 @@
 import { AbortSignal } from "./abort";
-/**
- * A collection of key/value pairs with case-insensitive keys.
- */
+
 export interface Headers extends Map<string, string> {
-    /**
-     * Returns a new instance of Headers with the specified header set to the
-     * provided value. Does not modify the original Headers instance.
-     *
-     * @param headerName    The name of the header to add or overwrite
-     * @param headerValue   The value to which the header should be set
-     */
+    
     withHeader(headerName: string, headerValue: string): Headers;
-    /**
-     * Returns a new instance of Headers without the specified header. Does not
-     * modify the original Headers instance.
-     *
-     * @param headerName    The name of the header to remove
-     */
+    
     withoutHeader(headerName: string): Headers;
 }
-/**
- * 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.
- */
+
 export interface HeaderBag {
     [key: string]: string;
 }
-/**
- * Represents an HTTP message with headers and an optional static or streaming
- * body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
- */
+
 export interface HttpMessage {
     headers: HeaderBag;
     body?: any;
 }
-/**
- * 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
- */
+
 export interface QueryParameterBag {
     [key: string]: string | Array<string> | null;
 }
@@ -63,30 +26,19 @@ export interface Endpoint {
     path: string;
     query?: QueryParameterBag;
 }
-/**
- * Interface an HTTP request class. Contains
- * addressing information in addition to standard message properties.
- */
+
 export interface HttpRequest extends HttpMessage, Endpoint {
     method: string;
 }
-/**
- * Represents an HTTP message as received in reply to a request. Contains a
- * numeric status code in addition to standard message properties.
- */
+
 export interface HttpResponse extends HttpMessage {
     statusCode: number;
 }
-/**
- * Represents HTTP message whose body has been resolved to a string. This is
- * used in parsing http message.
- */
+
 export interface ResolvedHttpResponse extends HttpResponse {
     body: string;
 }
-/**
- * Represents the options that may be passed to an Http Handler.
- */
+
 export interface HttpHandlerOptions {
     abortSignal?: AbortSignal;
 }

package/dist-types/ts3.4/index.d.ts

@@ -6,10 +6,10 @@ export * from "./crypto";
 export * from "./eventStream";
 export * from "./http";
 export * from "./logger";
-export * from "./pagination";
-export * from "./serde";
 export * from "./middleware";
+export * from "./pagination";
 export * from "./response";
+export * from "./serde";
 export * from "./shapes";
 export * from "./signature";
 export * from "./transfer";

package/dist-types/ts3.4/logger.d.ts

@@ -1,23 +1,11 @@
-/**
- * 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 new Logger({logLevel: 'warn'}) will print all the warn and error
- * message.
- */
+
 export declare type LogLevel = "all" | "log" | "info" | "warn" | "error" | "off";
-/**
- * An object consumed by Logger constructor to initiate a logger object.
- */
+
 export interface LoggerOptions {
     logger?: Logger;
     logLevel?: LogLevel;
 }
-/**
- * Represents a logger object that is available in HandlerExecutionContext
- * throughout the middleware stack.
- */
+
 export interface Logger {
     debug(content: object): void;
     info(content: object): void;

package/dist-types/ts3.4/middleware.d.ts

@@ -1,24 +1,14 @@
 import { Logger } from "./logger";
 import { UserAgent } from "./util";
 export interface InitializeHandlerArguments<Input extends object> {
-    /**
-     * User input to a command. Reflects the userland representation of the
-     * union of data types the command can effectively handle.
-     */
+    
     input: Input;
 }
 export interface InitializeHandlerOutput<Output extends object> extends DeserializeHandlerOutput<Output> {
     output: Output;
 }
 export interface SerializeHandlerArguments<Input extends object> extends InitializeHandlerArguments<Input> {
-    /**
-     * 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.
-     */
+    
     request?: unknown;
 }
 export interface SerializeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
@@ -28,9 +18,7 @@ export interface BuildHandlerArguments<Input extends object> extends FinalizeHan
 export interface BuildHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
 }
 export interface FinalizeHandlerArguments<Input extends object> extends SerializeHandlerArguments<Input> {
-    /**
-     * The user input serialized as a request.
-     */
+    
     request: unknown;
 }
 export interface FinalizeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
@@ -38,43 +26,21 @@ export interface FinalizeHandlerOutput<Output extends object> extends Initialize
 export interface DeserializeHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {
 }
 export interface DeserializeHandlerOutput<Output extends object> {
-    /**
-     * 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
-     */
+    
     response: unknown;
     output?: Output;
 }
 export interface InitializeHandler<Input extends object, Output extends object> {
-    /**
-     * Asynchronously converts an input object into an output object.
-     *
-     * @param args  An object containing a input to the command as well as any
-     *              associated or previously generated execution artifacts.
-     */
+    
     (args: InitializeHandlerArguments<Input>): Promise<InitializeHandlerOutput<Output>>;
 }
 export declare type Handler<Input extends object, Output extends object> = InitializeHandler<Input, Output>;
 export interface SerializeHandler<Input extends object, Output extends object> {
-    /**
-     * Asynchronously converts an input object into an output object.
-     *
-     * @param args  An object containing a input to the command as well as any
-     *              associated or previously generated execution artifacts.
-     */
+    
     (args: SerializeHandlerArguments<Input>): Promise<SerializeHandlerOutput<Output>>;
 }
 export interface FinalizeHandler<Input extends object, Output extends object> {
-    /**
-     * Asynchronously converts an input object into an output object.
-     *
-     * @param args  An object containing a input to the command as well as any
-     *              associated or previously generated execution artifacts.
-     */
+    
     (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>>;
 }
 export interface BuildHandler<Input extends object, Output extends object> {
@@ -83,43 +49,19 @@ export interface BuildHandler<Input extends object, Output extends object> {
 export interface DeserializeHandler<Input extends object, Output extends object> {
     (args: DeserializeHandlerArguments<Input>): Promise<DeserializeHandlerOutput<Output>>;
 }
-/**
- * A factory function that creates functions implementing the {Handler}
- * interface.
- */
+
 export interface InitializeMiddleware<Input extends object, Output extends object> {
-    /**
-     * @param next The handler to invoke after this middleware has operated on
-     * the user input and before this middleware operates on the output.
-     *
-     * @param context Invariant data and functions for use by the handler.
-     */
+    
     (next: InitializeHandler<Input, Output>, context: HandlerExecutionContext): InitializeHandler<Input, Output>;
 }
-/**
- * A factory function that creates functions implementing the {BuildHandler}
- * interface.
- */
+
 export interface SerializeMiddleware<Input extends object, Output extends object> {
-    /**
-     * @param next The handler to invoke after this middleware has operated on
-     * the user input and before this middleware operates on the output.
-     *
-     * @param context Invariant data and functions for use by the handler.
-     */
+    
     (next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output>;
 }
-/**
- * A factory function that creates functions implementing the {FinalizeHandler}
- * interface.
- */
+
 export interface FinalizeRequestMiddleware<Input extends object, Output extends object> {
-    /**
-     * @param next The handler to invoke after this middleware has operated on
-     * the user input and before this middleware operates on the output.
-     *
-     * @param context Invariant data and functions for use by the handler.
-     */
+    
     (next: FinalizeHandler<Input, Output>, context: HandlerExecutionContext): FinalizeHandler<Input, Output>;
 }
 export interface BuildMiddleware<Input extends object, Output extends object> {
@@ -129,80 +71,31 @@ export interface DeserializeMiddleware<Input extends object, Output extends obje
     (next: DeserializeHandler<Input, Output>, context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
 }
 export declare type MiddlewareType<Input extends object, Output extends object> = InitializeMiddleware<Input, Output> | SerializeMiddleware<Input, Output> | BuildMiddleware<Input, Output> | FinalizeRequestMiddleware<Input, Output> | DeserializeMiddleware<Input, Output>;
-/**
- * A factory function that creates the terminal handler atop which a middleware
- * stack sits.
- */
+
 export interface Terminalware {
     <Input extends object, Output extends object>(context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
 }
 export declare type Step = "initialize" | "serialize" | "build" | "finalizeRequest" | "deserialize";
 export declare type Priority = "high" | "normal" | "low";
 export interface HandlerOptions {
-    /**
-     * 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.
-     *
-     * @default 'initialize'
-     */
+    
     step?: Step;
-    /**
-     * A list of strings to any that identify the general purpose or important
-     * characteristics of a given handler.
-     */
+    
     tags?: Array<string>;
-    /**
-     * A unique name to refer to a middleware
-     */
+    
     name?: string;
-    /**
-     * A flag to override the existing middleware with the same name. Without
-     * setting it, adding middleware with duplicated name will throw an exception.
-     * @internal
-     */
+    
     override?: boolean;
 }
 export interface AbsoluteLocation {
-    /**
-     * By default middleware will be added to individual step in un-guaranteed order.
-     * In the case that
-     *
-     * @default 'normal'
-     */
+    
     priority?: Priority;
 }
 export declare type Relation = "before" | "after";
 export interface RelativeLocation {
-    /**
-     * Specify the relation to be before or after a know middleware.
-     */
+    
     relation: Relation;
-    /**
-     * A known middleware name to indicate inserting middleware's location.
-     */
+    
     toMiddleware: string;
 }
 export declare type RelativeMiddlewareOptions = RelativeLocation & Pick<HandlerOptions, Exclude<keyof HandlerOptions, "step">>;
@@ -221,118 +114,42 @@ export interface FinalizeRequestHandlerOptions extends HandlerOptions {
 export interface DeserializeHandlerOptions extends HandlerOptions {
     step: "deserialize";
 }
-/**
- * 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.
- */
+
 export interface MiddlewareStack<Input extends object, Output extends object> extends Pluggable<Input, Output> {
-    /**
-     * Add middleware to the stack to be executed during the "initialize" step,
-     * optionally specifying a priority, tags and name
-     */
+    
     add(middleware: InitializeMiddleware<Input, Output>, options?: InitializeHandlerOptions & AbsoluteLocation): void;
-    /**
-     * Add middleware to the stack to be executed during the "serialize" step,
-     * optionally specifying a priority, tags and name
-     */
+    
     add(middleware: SerializeMiddleware<Input, Output>, options: SerializeHandlerOptions & AbsoluteLocation): void;
-    /**
-     * Add middleware to the stack to be executed during the "build" step,
-     * optionally specifying a priority, tags and name
-     */
+    
     add(middleware: BuildMiddleware<Input, Output>, options: BuildHandlerOptions & AbsoluteLocation): void;
-    /**
-     * Add middleware to the stack to be executed during the "finalizeRequest" step,
-     * optionally specifying a priority, tags and name
-     */
+    
     add(middleware: FinalizeRequestMiddleware<Input, Output>, options: FinalizeRequestHandlerOptions & AbsoluteLocation): void;
-    /**
-     * Add middleware to the stack to be executed during the "deserialize" step,
-     * optionally specifying a priority, tags and name
-     */
+    
     add(middleware: DeserializeMiddleware<Input, Output>, options: DeserializeHandlerOptions & AbsoluteLocation): void;
-    /**
-     * Add middleware to a stack position before or after a known middleware，optionally
-     * specifying name and tags.
-     */
+    
     addRelativeTo(middleware: MiddlewareType<Input, Output>, options: RelativeMiddlewareOptions): void;
-    /**
-     * Apply a customization function to mutate the middleware stack, often
-     * used for customizations that requires mutating multiple middleware.
-     */
+    
     use(pluggable: Pluggable<Input, Output>): void;
-    /**
-     * Create a shallow clone of this stack. Step bindings and handler priorities
-     * and tags are preserved in the copy.
-     */
+    
     clone(): MiddlewareStack<Input, Output>;
-    /**
-     * 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.
-     */
+    
     remove(toRemove: MiddlewareType<Input, Output> | string): boolean;
-    /**
-     * Removes middleware that contains given tag
-     *
-     * Multiple middleware will potentially be removed
-     */
+    
     removeByTag(toRemove: string): boolean;
-    /**
-     * 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.
-     */
+    
     concat<InputType extends Input, OutputType extends Output>(from: MiddlewareStack<InputType, OutputType>): MiddlewareStack<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.
-     */
+    
     resolve<InputType extends Input, OutputType extends Output>(handler: DeserializeHandler<InputType, OutputType>, context: HandlerExecutionContext): InitializeHandler<InputType, OutputType>;
 }
-/**
- * Data and helper objects that are not expected to change from one execution of
- * a composed handler to another.
- */
+
 export interface HandlerExecutionContext {
-    /**
-     * A logger that may be invoked by any handler during execution of an
-     * operation.
-     */
+    
     logger?: Logger;
-    /**
-     * 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.
-     */
+    
     userAgent?: UserAgent;
     [key: string]: any;
 }
 export interface Pluggable<Input extends object, Output extends object> {
-    /**
-     * A function that mutate the passed in middleware stack. Functions implementing
-     * this interface can add, remove, modify existing middleware stack from clients
-     * or commands
-     */
+    
     applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
 }

package/dist-types/ts3.4/pagination.d.ts

@@ -1,12 +1,7 @@
 import { Client } from "./client";
-/**
- * Expected type definition of a paginator.
- */
+
 export declare type Paginator<T> = AsyncGenerator<T, T, unknown>;
-/**
- * Expected paginator configuration passed to an operation. Services will extend
- * this interface definition and may type client further.
- */
+
 export interface PaginationConfiguration {
     client: Client<any, any, any>;
     pageSize?: number;

package/dist-types/ts3.4/response.d.ts

@@ -1,34 +1,18 @@
 export interface ResponseMetadata {
-    /**
-     * The status code of the last HTTP response received for this operation.
-     */
+    
     httpStatusCode?: number;
-    /**
-     * A unique identifier for the last request sent for this operation. Often
-     * requested by AWS service teams to aid in debugging.
-     */
+    
     requestId?: string;
-    /**
-     * A secondary identifier for the last request sent. Used for debugging.
-     */
+    
     extendedRequestId?: string;
-    /**
-     * A tertiary identifier for the last request sent. Used for debugging.
-     */
+    
     cfId?: string;
-    /**
-     * The number of times this operation was attempted.
-     */
+    
     attempts?: number;
-    /**
-     * The total amount of time (in milliseconds) that was spent waiting between
-     * retry attempts.
-     */
+    
     totalRetryDelay?: number;
 }
 export interface MetadataBearer {
-    /**
-     * Metadata pertaining to this request.
-     */
+    
     $metadata: ResponseMetadata;
 }

package/dist-types/ts3.4/serde.d.ts

@@ -1,23 +1,15 @@
 import { Endpoint } from "./http";
 import { RequestHandler } from "./transfer";
 import { Decoder, Encoder, Provider } from "./util";
-/**
- * Interface for object requires an Endpoint set.
- */
+
 export interface EndpointBearer {
     endpoint: Provider<Endpoint>;
 }
 export interface StreamCollector {
-    /**
-     * A function that converts a stream into an array of bytes.
-     *
-     * @param stream  The low-level native stream from browser or Nodejs runtime
-     */
+    
     (stream: any): Promise<Uint8Array>;
 }
-/**
- * Request and Response serde util functions and settings for AWS services
- */
+
 export interface SerdeContext extends EndpointBearer {
     base64Encoder: Encoder;
     base64Decoder: Decoder;
@@ -28,22 +20,10 @@ export interface SerdeContext extends EndpointBearer {
     disableHostPrefix: boolean;
 }
 export interface RequestSerializer<Request, Context extends EndpointBearer = any> {
-    /**
-     * Converts the provided `input` into a request object
-     *
-     * @param input     The user input to serialize.
-     *
-     * @param context    Context containing runtime-specific util functions.
-     */
+    
     (input: any, context: Context): Promise<Request>;
 }
 export interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {
-    /**
-     * Converts the output of an operation into JavaScript types.
-     *
-     * @param output     The HTTP response received from the service
-     *
-     * @param context    context containing runtime-specific util functions.
-     */
+    
     (output: ResponseType, context: Context): Promise<OutputType>;
 }

package/dist-types/ts3.4/shapes.d.ts

@@ -1,45 +1,25 @@
+import { HttpResponse } from "./http";
 import { MetadataBearer } from "./response";
-/**
- * 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.
- */
+
 export declare type DocumentType = null | boolean | number | string | DocumentType[] | {
     [prop: string]: DocumentType;
 };
-/**
- * A structure shape with the error trait.
- * https://awslabs.github.io/smithy/spec/core.html#retryable-trait
- */
+
 export interface RetryableTrait {
-    /**
-     * Indicates that the error is a retryable throttling error.
-     */
+    
     readonly throttling?: boolean;
 }
-/**
- * Type that is implemented by all Smithy shapes marked with the
- * error trait.
- */
+
 export interface SmithyException {
-    /**
-     * The shape ID name of the exception.
-     */
+    
     readonly name: string;
-    /**
-     * Whether the client or server are at fault.
-     */
+    
     readonly $fault: "client" | "server";
-    /**
-     * The service that encountered the exception.
-     */
+    
     readonly $service?: string;
-    /**
-     * Indicates that an error MAY be retried by the client.
-     */
+    
     readonly $retryable?: RetryableTrait;
+    
+    readonly $response?: HttpResponse;
 }
 export declare type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;

package/dist-types/ts3.4/signature.d.ts

@@ -1,91 +1,40 @@
 import { HttpRequest } from "./http";
-/**
- * A {Date} object, a unix (epoch) timestamp in seconds, or a string that can be
- * understood by the JavaScript {Date} constructor.
- */
+
 export declare type DateInput = number | string | Date;
 export interface SigningArguments {
-    /**
-     * 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.
-     */
+    
     signingDate?: DateInput;
-    /**
-     * The service signing name. It will override the service name of the signer
-     * in current invocation
-     */
+    
     signingService?: string;
-    /**
-     * The region name to sign the request. It will override the signing region of the
-     * signer in current invocation
-     */
+    
     signingRegion?: string;
 }
 export interface RequestSigningArguments extends SigningArguments {
-    /**
-     * 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.
-     */
+    
     unsignableHeaders?: 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.
-     */
+    
     signableHeaders?: Set<string>;
 }
 export interface RequestPresigningArguments extends RequestSigningArguments {
-    /**
-     * The number of seconds before the presigned URL expires
-     */
+    
     expiresIn?: number;
-    /**
-     * 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.
-     */
+    
     unhoistableHeaders?: Set<string>;
 }
 export interface EventSigningArguments extends SigningArguments {
     priorSignature: string;
 }
 export interface RequestPresigner {
-    /**
-     * 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.
-     *
-     * @param requestToSign The request that should be signed.
-     * @param options       Additional signing options.
-     */
+    
     presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
 }
-/**
- * An object that signs request objects with AWS credentials using one of the
- * AWS authentication protocols.
- */
+
 export interface RequestSigner {
-    /**
-     * Sign the provided request for immediate dispatch.
-     */
+    
     sign(requestToSign: HttpRequest, options?: RequestSigningArguments): Promise<HttpRequest>;
 }
 export interface StringSigner {
-    /**
-     * Sign the provided `stringToSign` for use outside of the context of
-     * request signing. Typical uses include signed policy generation.
-     */
+    
     sign(stringToSign: string, options?: SigningArguments): Promise<string>;
 }
 export interface FormattedEvent {
@@ -93,8 +42,6 @@ export interface FormattedEvent {
     payload: Uint8Array;
 }
 export interface EventSigner {
-    /**
-     * Sign the individual event of the event stream.
-     */
+    
     sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
 }

package/dist-types/ts3.4/transfer.d.ts

@@ -2,11 +2,7 @@ export declare type RequestHandlerOutput<ResponseType> = {
     response: ResponseType;
 };
 export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
-    /**
-     * metadata contains information of a handler. For example
-     * 'h2' refers this handler is for handling HTTP/2 requests,
-     * whereas 'h1' refers handling HTTP1 requests
-     */
+    
     metadata?: RequestHandlerMetadata;
     destroy?: () => void;
     handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;

package/dist-types/ts3.4/util.d.ts

@@ -1,74 +1,34 @@
 import { Endpoint } from "./http";
 import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput } from "./middleware";
 import { MetadataBearer } from "./response";
-/**
- * A function that, given a TypedArray of bytes, can produce a string
- * representation thereof.
- *
- * @example An encoder function that converts bytes to hexadecimal
- * representation would return `'deadbeef'` when given `new
- * Uint8Array([0xde, 0xad, 0xbe, 0xef])`.
- */
+
 export interface Encoder {
     (input: Uint8Array): string;
 }
-/**
- * A function that, given a string, can derive the bytes represented by that
- * string.
- *
- * @example A decoder function that converts bytes to hexadecimal
- * representation would return `new Uint8Array([0xde, 0xad, 0xbe, 0xef])` when
- * given the string `'deadbeef'`.
- */
+
 export interface Decoder {
     (input: string): Uint8Array;
 }
-/**
- * A function that, when invoked, returns a promise that will be fulfilled with
- * a value of type T.
- *
- * @example A function that reads credentials from shared SDK configuration
- * files, assuming roles and collecting MFA tokens as necessary.
- */
+
 export interface Provider<T> {
     (): Promise<T>;
 }
-/**
- * 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 A function that reads a file stream and calculates
- * the size of the file.
- */
+
 export interface BodyLengthCalculator {
     (body: any): number | undefined;
 }
-/**
- * Interface that specifies the retry behavior
- */
+
 export interface RetryStrategy {
-    /**
-     * The retry mode describing how the retry strategy control the traffic flow.
-     */
+    
     mode?: string;
-    /**
-     * 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 {@link ResponseMetadata}
-     */
+    
     retry: <Input extends object, Output extends MetadataBearer>(next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>) => Promise<FinalizeHandlerOutput<Output>>;
 }
-/**
- * Parses a URL in string form into an Endpoint object.
- */
+
 export interface UrlParser {
     (url: string): Endpoint;
 }
-/**
- * Object containing regionalization information of
- * AWS services.
- */
+
 export interface RegionInfo {
     hostname: string;
     partition: string;
@@ -76,25 +36,21 @@ export interface RegionInfo {
     signingService?: string;
     signingRegion?: string;
 }
-/**
- * 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
- */
+
+export interface RegionInfoProviderOptions {
+    
+    useDualstackEndpoint: boolean;
+    
+    useFipsEndpoint: boolean;
+}
+
 export interface RegionInfoProvider {
-    (region: string, options?: any): Promise<RegionInfo | undefined>;
+    (region: string, options?: RegionInfoProviderOptions): Promise<RegionInfo | undefined>;
 }
-/**
- * A tuple that represents an API name and optional version
- * of a library built using the AWS SDK.
- */
+
 export declare type UserAgentPair = [
-    /*name*/ string,
-    /*version*/ string
+     string,
+     string
 ];
-/**
- * User agent data that to be put into the request's user
- * agent.
- */
+
 export declare type UserAgent = UserAgentPair[];

package/dist-types/ts3.4/waiter.d.ts

@@ -1,32 +1,15 @@
 import { AbortController } from "./abort";
 export interface WaiterConfiguration<Client> {
-    /**
-     * Required service client
-     */
+    
     client: Client;
-    /**
-     * The amount of time in seconds a user is willing to wait for a waiter to complete.
-     */
+    
     maxWaitTime: number;
-    /**
-     * @deprecated Use abortSignal
-     * Abort controller. Used for ending the waiter early.
-     */
+    
     abortController?: AbortController;
-    /**
-     * Abort Signal. Used for ending the waiter early.
-     */
+    
     abortSignal?: AbortController["signal"];
-    /**
-     * 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.
-     */
+    
     minDelay?: 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.
-     */
+    
     maxDelay?: number;
 }

package/dist-types/util.d.ts

@@ -76,6 +76,21 @@ export interface RegionInfo {
     signingService?: string;
     signingRegion?: string;
 }
+/**
+ * Options to pass when calling {@link RegionInfoProvider}
+ */
+export interface RegionInfoProviderOptions {
+    /**
+     * Enables IPv6/IPv4 dualstack endpoint.
+     * @default false
+     */
+    useDualstackEndpoint: boolean;
+    /**
+     * Enables FIPS compatible endpoints.
+     * @default false
+     */
+    useFipsEndpoint: boolean;
+}
 /**
  * Function returns designated service's regionalization
  * information from given region. Each service client
@@ -83,7 +98,7 @@ export interface RegionInfo {
  * to provide the default values of related configurations
  */
 export interface RegionInfoProvider {
-    (region: string, options?: any): Promise<RegionInfo | undefined>;
+    (region: string, options?: RegionInfoProviderOptions): Promise<RegionInfo | undefined>;
 }
 /**
  * A tuple that represents an API name and optional version

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@aws-sdk/types",
-  "version": "3.36.0",
+  "version": "3.46.0",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "description": "Types for the AWS SDK",
-  "devDependencies": {
-    "typescript": "~4.3.5"
-  },
   "scripts": {
     "build": "yarn build:cjs && yarn build:es && yarn build:types",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:es": "tsc -p tsconfig.es.json",
     "build:types": "tsc -p tsconfig.types.json",
-    "downlevel-dts": "downlevel-dts dist-types dist-types/ts3.4",
+    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
     "test": "exit 0"
   },
   "author": {
@@ -22,7 +19,7 @@
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 12.0.0"
   },
   "typesVersions": {
     "<4.0": {