@aws-sdk/types 3.50.0 → 3.52.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.52.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.51.0...v3.52.0) (2022-02-18)
+
+**Note:** Version bump only for package @aws-sdk/types
+
+
+
+
+
 # [3.50.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.49.0...v3.50.0) (2022-02-08)
 
 

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

@@ -0,0 +1,17 @@
+export interface AbortHandler {
+    (this: AbortSignal, ev: any): any;
+}
+
+export interface AbortSignal {
+    
+    readonly aborted: boolean;
+    
+    onabort: AbortHandler | null;
+}
+
+export interface AbortController {
+    
+    readonly signal: AbortSignal;
+    
+    abort(): void;
+}

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

@@ -0,0 +1,17 @@
+import { Command } from "./command";
+import { MiddlewareStack } from "./middleware";
+import { MetadataBearer } from "./response";
+
+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;
+}
+
+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/dist-types/ts3.4/command.d.ts

@@ -0,0 +1,7 @@
+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/dist-types/ts3.4/credentials.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "./util";
+
+export interface Credentials {
+    
+    readonly accessKeyId: string;
+    
+    readonly secretAccessKey: string;
+    
+    readonly sessionToken?: string;
+    
+    readonly expiration?: Date;
+}
+export declare type CredentialProvider = Provider<Credentials>;

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

@@ -0,0 +1,20 @@
+export declare type SourceData = string | ArrayBuffer | ArrayBufferView;
+
+export interface Hash {
+    
+    update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
+    
+    digest(): Promise<Uint8Array>;
+}
+
+export interface HashConstructor {
+    new (secret?: SourceData): Hash;
+}
+
+export interface StreamHasher<StreamType = any> {
+    (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
+}
+
+export interface randomValues {
+    (byteLength: number): Promise<Uint8Array>;
+}

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

@@ -0,0 +1,78 @@
+import { HttpRequest } from "./http";
+import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext } from "./middleware";
+import { MetadataBearer } from "./response";
+
+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;
+}
+
+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/dist-types/ts3.4/http.d.ts

@@ -0,0 +1,44 @@
+import { AbortSignal } from "./abort";
+
+export interface Headers extends Map<string, string> {
+    
+    withHeader(headerName: string, headerValue: string): Headers;
+    
+    withoutHeader(headerName: string): Headers;
+}
+
+export interface HeaderBag {
+    [key: string]: string;
+}
+
+export interface HttpMessage {
+    headers: HeaderBag;
+    body?: any;
+}
+
+export interface QueryParameterBag {
+    [key: string]: string | Array<string> | null;
+}
+export interface Endpoint {
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query?: QueryParameterBag;
+}
+
+export interface HttpRequest extends HttpMessage, Endpoint {
+    method: string;
+}
+
+export interface HttpResponse extends HttpMessage {
+    statusCode: number;
+}
+
+export interface ResolvedHttpResponse extends HttpResponse {
+    body: string;
+}
+
+export interface HttpHandlerOptions {
+    abortSignal?: AbortSignal;
+}

package/dist-types/ts3.4/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 "./middleware";
+export * from "./pagination";
+export * from "./response";
+export * from "./serde";
+export * from "./shapes";
+export * from "./signature";
+export * from "./transfer";
+export * from "./util";
+export * from "./waiter";

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

@@ -0,0 +1,14 @@
+
+export declare type LogLevel = "all" | "log" | "info" | "warn" | "error" | "off";
+
+export interface LoggerOptions {
+    logger?: Logger;
+    logLevel?: LogLevel;
+}
+
+export interface Logger {
+    debug(content: object): void;
+    info(content: object): void;
+    warn(content: object): void;
+    error(content: object): void;
+}

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

@@ -0,0 +1,155 @@
+import { Logger } from "./logger";
+import { UserAgent } from "./util";
+export interface InitializeHandlerArguments<Input extends object> {
+    
+    input: Input;
+}
+export interface InitializeHandlerOutput<Output extends object> extends DeserializeHandlerOutput<Output> {
+    output: Output;
+}
+export interface SerializeHandlerArguments<Input extends object> extends InitializeHandlerArguments<Input> {
+    
+    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> {
+    
+    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> {
+    
+    response: unknown;
+    output?: Output;
+}
+export interface InitializeHandler<Input extends object, Output extends object> {
+    
+    (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> {
+    
+    (args: SerializeHandlerArguments<Input>): Promise<SerializeHandlerOutput<Output>>;
+}
+export interface FinalizeHandler<Input extends object, Output extends object> {
+    
+    (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>>;
+}
+
+export interface InitializeMiddleware<Input extends object, Output extends object> {
+    
+    (next: InitializeHandler<Input, Output>, context: HandlerExecutionContext): InitializeHandler<Input, Output>;
+}
+
+export interface SerializeMiddleware<Input extends object, Output extends object> {
+    
+    (next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output>;
+}
+
+export interface FinalizeRequestMiddleware<Input extends object, Output extends object> {
+    
+    (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>;
+
+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 {
+    
+    step?: Step;
+    
+    tags?: Array<string>;
+    
+    name?: string;
+    
+    override?: boolean;
+}
+export interface AbsoluteLocation {
+    
+    priority?: Priority;
+}
+export declare type Relation = "before" | "after";
+export interface RelativeLocation {
+    
+    relation: Relation;
+    
+    toMiddleware: string;
+}
+export declare type RelativeMiddlewareOptions = RelativeLocation & Pick<HandlerOptions, Exclude<keyof 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";
+}
+
+export interface MiddlewareStack<Input extends object, Output extends object> extends Pluggable<Input, Output> {
+    
+    add(middleware: InitializeMiddleware<Input, Output>, options?: InitializeHandlerOptions & AbsoluteLocation): void;
+    
+    add(middleware: SerializeMiddleware<Input, Output>, options: SerializeHandlerOptions & AbsoluteLocation): void;
+    
+    add(middleware: BuildMiddleware<Input, Output>, options: BuildHandlerOptions & AbsoluteLocation): void;
+    
+    add(middleware: FinalizeRequestMiddleware<Input, Output>, options: FinalizeRequestHandlerOptions & AbsoluteLocation): void;
+    
+    add(middleware: DeserializeMiddleware<Input, Output>, options: DeserializeHandlerOptions & AbsoluteLocation): void;
+    
+    addRelativeTo(middleware: MiddlewareType<Input, Output>, options: RelativeMiddlewareOptions): void;
+    
+    use(pluggable: Pluggable<Input, Output>): void;
+    
+    clone(): MiddlewareStack<Input, Output>;
+    
+    remove(toRemove: MiddlewareType<Input, Output> | string): boolean;
+    
+    removeByTag(toRemove: string): boolean;
+    
+    concat<InputType extends Input, OutputType extends Output>(from: MiddlewareStack<InputType, OutputType>): MiddlewareStack<InputType, OutputType>;
+    
+    resolve<InputType extends Input, OutputType extends Output>(handler: DeserializeHandler<InputType, OutputType>, context: HandlerExecutionContext): InitializeHandler<InputType, OutputType>;
+}
+
+export interface HandlerExecutionContext {
+    
+    logger?: Logger;
+    
+    userAgent?: UserAgent;
+    [key: string]: any;
+}
+export interface Pluggable<Input extends object, Output extends object> {
+    
+    applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
+}

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

@@ -0,0 +1,9 @@
+import { Client } from "./client";
+
+export declare type Paginator<T> = AsyncGenerator<T, T, unknown>;
+
+export interface PaginationConfiguration {
+    client: Client<any, any, any>;
+    pageSize?: number;
+    startingToken?: any;
+}

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

@@ -0,0 +1,18 @@
+export interface ResponseMetadata {
+    
+    httpStatusCode?: number;
+    
+    requestId?: string;
+    
+    extendedRequestId?: string;
+    
+    cfId?: string;
+    
+    attempts?: number;
+    
+    totalRetryDelay?: number;
+}
+export interface MetadataBearer {
+    
+    $metadata: ResponseMetadata;
+}

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

@@ -0,0 +1,29 @@
+import { Endpoint } from "./http";
+import { RequestHandler } from "./transfer";
+import { Decoder, Encoder, Provider } from "./util";
+
+export interface EndpointBearer {
+    endpoint: Provider<Endpoint>;
+}
+export interface StreamCollector {
+    
+    (stream: any): Promise<Uint8Array>;
+}
+
+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> {
+    
+    (input: any, context: Context): Promise<Request>;
+}
+export interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {
+    
+    (output: ResponseType, context: Context): Promise<OutputType>;
+}

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

@@ -0,0 +1,26 @@
+import { HttpResponse } from "./http";
+import { MetadataBearer } from "./response";
+
+export declare type DocumentType = null | boolean | number | string | DocumentType[] | {
+    [prop: string]: DocumentType;
+};
+
+export interface RetryableTrait {
+    
+    readonly throttling?: boolean;
+}
+
+export interface SmithyException {
+    
+    readonly name: string;
+    
+    readonly $fault: "client" | "server";
+    
+    readonly $service?: string;
+    
+    readonly $retryable?: RetryableTrait;
+    
+    readonly $response?: HttpResponse;
+}
+
+export declare type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;

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

@@ -0,0 +1,47 @@
+import { HttpRequest } from "./http";
+
+export declare type DateInput = number | string | Date;
+export interface SigningArguments {
+    
+    signingDate?: DateInput;
+    
+    signingService?: string;
+    
+    signingRegion?: string;
+}
+export interface RequestSigningArguments extends SigningArguments {
+    
+    unsignableHeaders?: Set<string>;
+    
+    signableHeaders?: Set<string>;
+}
+export interface RequestPresigningArguments extends RequestSigningArguments {
+    
+    expiresIn?: number;
+    
+    unhoistableHeaders?: Set<string>;
+}
+export interface EventSigningArguments extends SigningArguments {
+    priorSignature: string;
+}
+export interface RequestPresigner {
+    
+    presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
+}
+
+export interface RequestSigner {
+    
+    sign(requestToSign: HttpRequest, options?: RequestSigningArguments): Promise<HttpRequest>;
+}
+export interface StringSigner {
+    
+    sign(stringToSign: string, options?: SigningArguments): Promise<string>;
+}
+export interface FormattedEvent {
+    headers: Uint8Array;
+    payload: Uint8Array;
+}
+export interface EventSigner {
+    
+    sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
+}

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

@@ -0,0 +1,12 @@
+export declare type RequestHandlerOutput<ResponseType> = {
+    response: ResponseType;
+};
+export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
+    
+    metadata?: RequestHandlerMetadata;
+    destroy?: () => void;
+    handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
+}
+export interface RequestHandlerMetadata {
+    handlerProtocol: string;
+}

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

@@ -0,0 +1,56 @@
+import { Endpoint } from "./http";
+import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput } from "./middleware";
+import { MetadataBearer } from "./response";
+
+export interface Encoder {
+    (input: Uint8Array): string;
+}
+
+export interface Decoder {
+    (input: string): Uint8Array;
+}
+
+export interface Provider<T> {
+    (): Promise<T>;
+}
+
+export interface BodyLengthCalculator {
+    (body: any): number | undefined;
+}
+
+export interface RetryStrategy {
+    
+    mode?: string;
+    
+    retry: <Input extends object, Output extends MetadataBearer>(next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>) => Promise<FinalizeHandlerOutput<Output>>;
+}
+
+export interface UrlParser {
+    (url: string): Endpoint;
+}
+
+export interface RegionInfo {
+    hostname: string;
+    partition: string;
+    path?: string;
+    signingService?: string;
+    signingRegion?: string;
+}
+
+export interface RegionInfoProviderOptions {
+    
+    useDualstackEndpoint: boolean;
+    
+    useFipsEndpoint: boolean;
+}
+
+export interface RegionInfoProvider {
+    (region: string, options?: RegionInfoProviderOptions): Promise<RegionInfo | undefined>;
+}
+
+export declare type UserAgentPair = [
+     string,
+     string
+];
+
+export declare type UserAgent = UserAgentPair[];

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

@@ -0,0 +1,15 @@
+import { AbortController } from "./abort";
+export interface WaiterConfiguration<Client> {
+    
+    client: Client;
+    
+    maxWaitTime: number;
+    
+    abortController?: AbortController;
+    
+    abortSignal?: AbortController["signal"];
+    
+    minDelay?: number;
+    
+    maxDelay?: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/types",
-  "version": "3.50.0",
+  "version": "3.52.0",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
@@ -11,7 +11,7 @@
     "build:es": "tsc -p tsconfig.es.json",
     "build:types": "tsc -p tsconfig.types.json",
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
-    "clean": "rimraf ./dist-*",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
     "test": "exit 0"
   },
   "author": {