@aws-sdk/types 3.32.0 → 3.34.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.34.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.33.0...v3.34.0) (2021-09-24)
+
+
+### Features
+
+* **non-clients:** remove comments from transpiled JS files ([#2813](https://github.com/aws/aws-sdk-js-v3/issues/2813)) ([e6fc7f3](https://github.com/aws/aws-sdk-js-v3/commit/e6fc7f3e0fa74785590ac19e7ed143c916bb9b6e))
+
+
+
+
+
 # [3.32.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.31.0...v3.32.0) (2021-09-17)
 
 **Note:** Version bump only for package @aws-sdk/types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/types",
-  "version": "3.32.0",
+  "version": "3.34.0",
   "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.js",
   "types": "./dist/types/index.d.ts",
@@ -9,9 +9,10 @@
     "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": "yarn build:es && yarn build:cjs",
+    "build:types": "tsc -p tsconfig.types.json",
     "downlevel-dts": "downlevel-dts dist/types dist/types/ts3.4",
     "test": "exit 0"
   },

package/src/abort.d.ts

@@ -0,0 +1,42 @@
+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/src/client.d.ts

@@ -0,0 +1,34 @@
+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>;
+  send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
+  destroy: () => void;
+}
+export {};

package/src/command.d.ts

@@ -0,0 +1,17 @@
+import { Handler, MiddlewareStack } from "./middleware";
+import { MetadataBearer } from "./response";
+export interface Command<
+  ClientInput extends object,
+  InputType extends ClientInput,
+  ClientOutput extends MetadataBearer,
+  OutputType extends ClientOutput,
+  ResolvedConfiguration
+> {
+  readonly input: InputType;
+  readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
+  resolveMiddleware(
+    stack: MiddlewareStack<ClientInput, ClientOutput>,
+    configuration: ResolvedConfiguration,
+    options: any
+  ): Handler<InputType, OutputType>;
+}

package/src/credentials.d.ts

@@ -0,0 +1,24 @@
+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/src/crypto.d.ts

@@ -0,0 +1,45 @@
+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/src/eventStream.d.ts

@@ -0,0 +1,100 @@
+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;
+}
+export interface MessageHeaders {
+  [name: string]: MessageHeaderValue;
+}
+export interface BooleanHeaderValue {
+  type: "boolean";
+  value: boolean;
+}
+export interface ByteHeaderValue {
+  type: "byte";
+  value: number;
+}
+export interface ShortHeaderValue {
+  type: "short";
+  value: number;
+}
+export interface IntegerHeaderValue {
+  type: "integer";
+  value: number;
+}
+export interface LongHeaderValue {
+  type: "long";
+  value: Int64;
+}
+export interface BinaryHeaderValue {
+  type: "binary";
+  value: Uint8Array;
+}
+export interface StringHeaderValue {
+  type: "string";
+  value: string;
+}
+export interface TimestampHeaderValue {
+  type: "timestamp";
+  value: Date;
+}
+export interface UuidHeaderValue {
+  type: "uuid";
+  value: string;
+}
+export declare type MessageHeaderValue =
+  | BooleanHeaderValue
+  | ByteHeaderValue
+  | ShortHeaderValue
+  | IntegerHeaderValue
+  | LongHeaderValue
+  | BinaryHeaderValue
+  | StringHeaderValue
+  | TimestampHeaderValue
+  | UuidHeaderValue;
+export interface Int64 {
+  readonly bytes: Uint8Array;
+  valueOf: () => number;
+  toString: () => string;
+}
+/**
+ * Util functions for serializing or deserializing event stream
+ */
+export interface EventStreamSerdeContext {
+  eventStreamMarshaller: EventStreamMarshaller;
+}
+export interface EventStreamMarshaller {
+  deserialize: (body: any, deserializer: (input: { [event: string]: Message }) => any) => AsyncIterable<any>;
+  serialize: (input: AsyncIterable<any>, serializer: (event: any) => Message) => any;
+}
+export interface EventStreamRequestSigner {
+  sign(request: HttpRequest): Promise<HttpRequest>;
+}
+export interface EventStreamPayloadHandler {
+  handle: <Input extends object, Output extends MetadataBearer>(
+    next: FinalizeHandler<Input, Output>,
+    args: FinalizeHandlerArguments<Input>,
+    context?: HandlerExecutionContext
+  ) => Promise<FinalizeHandlerOutput<Output>>;
+}
+export interface EventStreamPayloadHandlerProvider {
+  (options: any): EventStreamPayloadHandler;
+}
+export interface EventStreamSerdeProvider {
+  (options: any): EventStreamMarshaller;
+}
+export interface EventStreamSignerProvider {
+  (options: any): EventStreamRequestSigner;
+}

package/src/http.d.ts

@@ -0,0 +1,92 @@
+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;
+}
+export interface Endpoint {
+  protocol: string;
+  hostname: string;
+  port?: number;
+  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/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./abort";
+export * from "./client";
+export * from "./command";
+export * from "./credentials";
+export * from "./crypto";
+export * from "./eventStream";
+export * from "./http";
+export * from "./logger";
+export * from "./pagination";
+export * from "./serde";
+export * from "./middleware";
+export * from "./response";
+export * from "./shapes";
+export * from "./signature";
+export * from "./transfer";
+export * from "./util";
+export * from "./waiter";

package/src/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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;
+  warn(content: object): void;
+  error(content: object): void;
+}

package/src/middleware.d.ts

@@ -0,0 +1,346 @@
+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> {}
+export interface BuildHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {}
+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> {}
+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> {
+  (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
+}
+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> {
+  (next: BuildHandler<Input, Output>, context: HandlerExecutionContext): BuildHandler<Input, Output>;
+}
+export interface DeserializeMiddleware<Input extends object, Output extends object> {
+  (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 & Omit<HandlerOptions, "step">;
+export interface InitializeHandlerOptions extends HandlerOptions {
+  step?: "initialize";
+}
+export interface SerializeHandlerOptions extends HandlerOptions {
+  step: "serialize";
+}
+export interface BuildHandlerOptions extends HandlerOptions {
+  step: "build";
+}
+export interface FinalizeRequestHandlerOptions extends HandlerOptions {
+  step: "finalizeRequest";
+}
+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/src/pagination.d.ts

@@ -0,0 +1,14 @@
+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;
+  startingToken?: any;
+}

package/src/response.d.ts

@@ -0,0 +1,34 @@
+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/src/serde.d.ts

@@ -0,0 +1,49 @@
+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;
+  utf8Encoder: Encoder;
+  utf8Decoder: Decoder;
+  streamCollector: StreamCollector;
+  requestHandler: RequestHandler<any, any>;
+  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/src/shapes.d.ts

@@ -0,0 +1,51 @@
+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;
+}
+export declare type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;

package/src/signature.d.ts

@@ -0,0 +1,100 @@
+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 {
+  headers: Uint8Array;
+  payload: Uint8Array;
+}
+export interface EventSigner {
+  /**
+   * Sign the individual event of the event stream.
+   */
+  sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
+}

package/src/transfer.d.ts

@@ -0,0 +1,16 @@
+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>>;
+}
+export interface RequestHandlerMetadata {
+  handlerProtocol: string;
+}

package/src/util.d.ts

@@ -0,0 +1,100 @@
+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;
+  path?: string;
+  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 RegionInfoProvider {
+  (region: string, options?: any): 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];
+/**
+ * User agent data that to be put into the request's user
+ * agent.
+ */
+export declare type UserAgent = UserAgentPair[];

package/src/waiter.d.ts

@@ -0,0 +1,32 @@
+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/tsconfig.cjs.json

@@ -1,9 +1,8 @@
 {
   "compilerOptions": {
-    "declarationDir": "./dist/types",
-    "rootDir": "./src",
-    "outDir": "./dist/cjs",
-    "baseUrl": "."
+    "baseUrl": ".",
+    "outDir": "dist/cjs",
+    "rootDir": "src"
   },
   "extends": "../../tsconfig.cjs.json",
   "include": ["src/"]

package/tsconfig.es.json

@@ -1,10 +1,9 @@
 {
   "compilerOptions": {
+    "baseUrl": ".",
     "lib": ["es5", "es2015.promise", "es2015.collection", "es2015.iterable", "es2015.symbol.wellknown"],
-    "declarationDir": "./dist/types",
-    "rootDir": "./src",
-    "outDir": "./dist/es",
-    "baseUrl": "."
+    "outDir": "dist/es",
+    "rootDir": "src"
   },
   "extends": "../../tsconfig.es.json",
   "include": ["src/"]

package/tsconfig.types.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "declarationDir": "dist/types",
+    "rootDir": "src"
+  },
+  "extends": "../../tsconfig.types.json",
+  "include": ["src/"]
+}