@cdk8s/awscdk-resolver 0.0.624 → 0.0.626

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/index.browser.d.ts

@@ -0,0 +1,11 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export declare const fileStreamHasher: symbol;
+export declare const readableStreamHasher: symbol;
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export declare const Md5Node: symbol;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export declare const Crc32Node: symbol;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export declare const Sha256Node: symbol;
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/index.d.ts

@@ -0,0 +1,11 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export { fileStreamHasher } from "./hash-stream-node/fileStreamHasher";
+export { readableStreamHasher } from "./hash-stream-node/readableStreamHasher";
+export { Md5Js } from "./md5/Md5Js";
+export { Md5Node, Md5Node as Md5 } from "./md5/Md5Node";
+export { Crc32Js } from "./crc32/Crc32Js";
+export { Crc32Node, Crc32Node as Crc32 } from "./crc32/Crc32Node";
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256Node, Sha256Node as Sha256 } from "./sha256/Sha256Node";
+export { Sha256WebCrypto } from "./sha256/Sha256WebCrypto";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/index.native.d.ts

@@ -0,0 +1,11 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export declare const fileStreamHasher: symbol;
+export declare const readableStreamHasher: symbol;
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export declare const Md5Node: symbol;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export declare const Crc32Node: symbol;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export declare const Sha256Node: symbol;
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader.native";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/md5/Md5Js.d.ts

@@ -0,0 +1,19 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * Pure-JS MD5 implementation. Used as fallback where node:crypto is unavailable.
+ *
+ * @public
+ */
+export declare class Md5Js implements Checksum {
+    readonly digestLength = 16;
+    private state;
+    private writeBuffer;
+    private bufferLength;
+    private bytesHashed;
+    update(sourceData: SourceData): void;
+    /**
+     * Non-destructive: works on copies so update() may continue after digest().
+     */
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/md5/Md5Node.d.ts

@@ -0,0 +1,17 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * MD5 using Node.js crypto native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Md5Node extends Checksum {
+    readonly digestLength: 16;
+    /**
+     * @override
+     */
+    update(data: SourceData): void;
+}
+/**
+ * @public
+ */
+export declare const Md5Node: new () => Md5Node;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/sha256/Sha256Js.d.ts

@@ -0,0 +1,28 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * Pure JS SHA-256 implementation with HMAC support.
+ * @see https://csrc.nist.gov/pubs/fips/180-4/upd1/final
+ * @public
+ */
+export declare class Sha256Js implements Checksum {
+    readonly digestLength = 32;
+    /** Eight 32-bit words representing the current hash state. */
+    private state;
+    /** Reused message schedule array (W), allocated on first use of hashBuffer. */
+    private w?;
+    /** Accumulates input bytes until a full 64-byte block is ready. */
+    private buffer;
+    private bufferLength;
+    private bytesHashed;
+    private finished;
+    private readonly inner?;
+    private readonly outer?;
+    constructor(secret?: SourceData);
+    update(data: SourceData): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private digestSync;
+    private static normalizeKey;
+    private hashBuffer;
+    private hashBufferWith;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/sha256/Sha256Node.d.ts

@@ -0,0 +1,13 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * SHA-256 using Node.js crypto native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Sha256Node extends Checksum {
+    readonly digestLength: 32;
+}
+/**
+ * @public
+ */
+export declare const Sha256Node: new (secret?: SourceData) => Sha256Node;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/checksum/sha256/Sha256WebCrypto.d.ts

@@ -0,0 +1,22 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * SHA-256 using the Web Crypto API (crypto.subtle) when available,
+ * falling back to the pure JS implementation.
+ *
+ * Caution: this implementation is forced to buffer the data entirely.
+ * Use the pure-JS or Sha256Node implementations for large streaming data.
+ * @public
+ */
+export declare class Sha256WebCrypto implements Checksum {
+    readonly digestLength: 32;
+    private readonly secret?;
+    private pending;
+    private pendingBytes;
+    private fallback?;
+    private finished;
+    constructor(secret?: SourceData);
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private switchToFallback;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/index.d.ts

@@ -0,0 +1,27 @@
+export { constructStack } from "./middleware-stack/MiddlewareStack";
+export { getSmithyContext } from "@smithy/core/transport";
+export { normalizeProvider } from "@smithy/core/transport";
+export { invalidFunction } from "./invalid-dependency/invalidFunction";
+export { invalidProvider } from "./invalid-dependency/invalidProvider";
+export { createWaiter } from "./util-waiter/createWaiter";
+export { waiterServiceDefaults, WaiterState, checkExceptions, WaiterConfiguration, WaiterOptions, WaiterResult } from "./util-waiter/waiter";
+export { Client, SmithyConfiguration, SmithyResolvedConfiguration } from "./smithy-client/client";
+export { Command, CommandImpl } from "./smithy-client/command";
+export { SENSITIVE_STRING } from "./smithy-client/constants";
+export { createAggregatedClient } from "./smithy-client/create-aggregated-client";
+export { throwDefaultError, withBaseException } from "./smithy-client/default-error-handler";
+export { loadConfigsForDefaultMode, DefaultsMode, ResolvedDefaultsMode, DefaultsModeConfigs } from "./smithy-client/defaults-mode";
+export { emitWarningIfUnsupportedVersion } from "./smithy-client/emitWarningIfUnsupportedVersion";
+export { ServiceException, decorateServiceException, ExceptionOptionType, ServiceExceptionOptions } from "./smithy-client/exceptions";
+export { getDefaultExtensionConfiguration, getDefaultClientConfiguration, resolveDefaultRuntimeConfig, DefaultExtensionRuntimeConfigType } from "./smithy-client/extensions/defaultExtensionConfiguration";
+export { AlgorithmId, getChecksumConfiguration, resolveChecksumRuntimeConfig, ChecksumAlgorithm, ChecksumConfiguration, PartialChecksumRuntimeConfigType } from "./smithy-client/extensions/checksum";
+export { getRetryConfiguration, resolveRetryRuntimeConfig, PartialRetryRuntimeConfigType } from "./smithy-client/extensions/retry";
+export { getArrayIfSingleItem } from "./smithy-client/get-array-if-single-item";
+export { getValueFromTextNode } from "./smithy-client/get-value-from-text-node";
+export { isSerializableHeaderValue } from "./smithy-client/is-serializable-header-value";
+export { NoOpLogger } from "./smithy-client/NoOpLogger";
+export { map, convertMap, take, ObjectMappingInstructions, SourceMappingInstructions, ObjectMappingInstruction, UnfilteredValue, LazyValueInstruction, ConditionalLazyValueInstruction, SimpleValueInstruction, ConditionalValueInstruction, SourceMappingInstruction, FilterStatus, FilterStatusSupplier, ValueFilteringFunction, ValueSupplier, ValueMapper, Value } from "./smithy-client/object-mapping";
+export { schemaLogFilter } from "./smithy-client/schemaLogFilter";
+export { serializeFloat, serializeDateTime } from "./smithy-client/ser-utils";
+export { _json } from "./smithy-client/serde-json";
+export { makeBuilder } from "./smithy-client/client-command-builder";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/invalid-dependency/invalidFunction.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const invalidFunction: (message: string) => () => never;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/invalid-dependency/invalidProvider.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const invalidProvider: (message: string) => Provider<any>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/middleware-stack/MiddlewareStack.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareStack } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const constructStack: <Input extends object, Output extends object>() => MiddlewareStack<Input, Output>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/middleware-stack/types.d.ts

@@ -0,0 +1,22 @@
+import { AbsoluteLocation, HandlerOptions, MiddlewareType, Priority, RelativeLocation, Step } from "@smithy/types";
+export interface MiddlewareEntry<Input extends object, Output extends object> extends HandlerOptions {
+    middleware: MiddlewareType<Input, Output>;
+}
+export interface AbsoluteMiddlewareEntry<Input extends object, Output extends object> extends MiddlewareEntry<Input, Output>, AbsoluteLocation {
+    step: Step;
+    priority: Priority;
+}
+export interface RelativeMiddlewareEntry<Input extends object, Output extends object> extends MiddlewareEntry<Input, Output>, RelativeLocation {
+}
+export type Normalized<T extends MiddlewareEntry<Input, Output>, Input extends object = {}, Output extends object = {}> = T & {
+    after: Normalized<RelativeMiddlewareEntry<Input, Output>, Input, Output>[];
+    before: Normalized<RelativeMiddlewareEntry<Input, Output>, Input, Output>[];
+};
+export interface NormalizedRelativeEntry<Input extends object, Output extends object> extends HandlerOptions {
+    step: Step;
+    middleware: MiddlewareType<Input, Output>;
+    next?: NormalizedRelativeEntry<Input, Output>;
+    prev?: NormalizedRelativeEntry<Input, Output>;
+    priority: null;
+}
+export type NamedMiddlewareEntriesMap<Input extends object, Output extends object> = Record<string, MiddlewareEntry<Input, Output>>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/NoOpLogger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class NoOpLogger implements Logger {
+    trace(): void;
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/client-command-builder.d.ts

@@ -0,0 +1,22 @@
+import { EndpointParameterInstructions, Logger, MetadataBearer, OptionalParameter, Pluggable, RequestHandler, StaticOperationSchema } from "@smithy/types";
+import { CommandImpl } from "./command";
+/**
+ * Higher order factory for Command builders specific to a client.
+ * Produces a command factory that creates Command classes with
+ * pre-configured endpoint params, middleware, and schema.
+ *
+ * @param common - common endpoint params.
+ * @param service - service shape name.
+ * @param name - SDK Client Name.
+ * @param ep - endpoint plugin provider.
+ *
+ * @internal
+ */
+export declare function makeBuilder<C extends {
+    logger?: Logger;
+    requestHandler: RequestHandler<any, any, any>;
+}, SI extends object, SO extends MetadataBearer>(common: EndpointParameterInstructions, service: string, name: string, ep: (config: any, instructions: any) => Pluggable<any, any>): <I extends SI, O extends SO>(added: EndpointParameterInstructions, plugins: (CommandCtor: any, clientStack: any, config: any, options: any) => Pluggable<any, any>[], op: string, $: StaticOperationSchema, smithyContext?: Record<string, unknown>) => {
+    new (input: I): CommandImpl<I, O, C, SI, SO>;
+    new (...[input]: OptionalParameter<I>): CommandImpl<I, O, C, SI, SO>;
+    getEndpointParameterInstructions(): EndpointParameterInstructions;
+};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/client.d.ts

@@ -0,0 +1,84 @@
+import { $ClientProtocol, $ClientProtocolCtor, ClientProtocol, ClientProtocolCtor, Command, FetchHttpHandlerOptions, Client as IClient, MetadataBearer, MiddlewareStack, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+/**
+ * @public
+ */
+export interface SmithyConfiguration<HandlerOptions> {
+    /**
+     * @public
+     */
+    requestHandler: RequestHandler<any, any, HandlerOptions> | NodeHttpHandlerOptions | FetchHttpHandlerOptions | Record<string, unknown>;
+    /**
+     * Default false.
+     * When true, the client will only resolve the middleware stack once per
+     * Command class. This means modifying the middlewareStack of the
+     * command or client after requests have been made will not be
+     * recognized.
+     * Calling client.destroy() also clears this cache.
+     * Enable this only if needing the additional time saved (0-1ms per request)
+     * and not needing middleware modifications between requests.
+     *
+     * @public
+     */
+    cacheMiddleware?: boolean;
+    /**
+     * A client request/response protocol or constructor of one.
+     * A protocol in this context is not e.g. https.
+     * It is the combined implementation of how to (de)serialize and create
+     * the messages (e.g. http requests/responses) that are being exchanged.
+     *
+     * @public
+     */
+    protocol?: ClientProtocol<any, any> | $ClientProtocol<any, any> | ClientProtocolCtor<any, any> | $ClientProtocolCtor<any, any>;
+    /**
+     * These are automatically generated and will be passed to the
+     * config.protocol if given as a constructor.
+     * @internal
+     */
+    protocolSettings?: {
+        defaultNamespace?: string;
+        [setting: string]: unknown;
+    };
+    /**
+     * The API version set internally by the SDK, and is
+     * not planned to be used by customer code.
+     * @internal
+     */
+    readonly apiVersion: string;
+}
+/**
+ * @internal
+ */
+export type SmithyResolvedConfiguration<HandlerOptions> = {
+    requestHandler: RequestHandler<any, any, HandlerOptions>;
+    cacheMiddleware?: boolean;
+    protocol?: ClientProtocol<any, any> | $ClientProtocol<any, any>;
+    protocolSettings?: {
+        defaultNamespace?: string;
+        [setting: string]: unknown;
+    };
+    readonly apiVersion: string;
+};
+/**
+ * @public
+ */
+export declare class Client<HandlerOptions, ClientInput extends object, ClientOutput extends MetadataBearer, ResolvedClientConfiguration extends SmithyResolvedConfiguration<HandlerOptions>> implements IClient<ClientInput, ClientOutput, ResolvedClientConfiguration> {
+    readonly config: ResolvedClientConfiguration;
+    middlewareStack: MiddlewareStack<ClientInput, ClientOutput>;
+    /**
+     * Holds an object reference to the initial configuration object.
+     * Used to check that the config resolver stack does not create
+     * dangling instances of an intermediate form of the configuration object.
+     *
+     * @internal
+     */
+    initConfig?: object;
+    /**
+     * May be used to cache the resolved handler function for a Command class.
+     */
+    private handlers?;
+    constructor(config: ResolvedClientConfiguration);
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options?: HandlerOptions): Promise<OutputType>;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, cb: (err: any, data?: OutputType) => void): void;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options: HandlerOptions, cb: (err: any, data?: OutputType) => void): void;
+    destroy(): void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/command.d.ts

@@ -0,0 +1,118 @@
+import { EndpointParameterInstructions, Handler, HandlerExecutionContext, Command as ICommand, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MiddlewareStack as IMiddlewareStack, Logger, MetadataBearer, OperationSchema, OptionalParameter, Pluggable, RequestHandler, SerdeContext, StaticOperationSchema } from "@smithy/types";
+/**
+ * @public
+ */
+export declare abstract class Command<Input extends ClientInput, Output extends ClientOutput, ResolvedClientConfiguration, ClientInput extends object = any, ClientOutput extends MetadataBearer = any> implements ICommand<ClientInput, Input, ClientOutput, Output, ResolvedClientConfiguration> {
+    abstract input: Input;
+    readonly middlewareStack: IMiddlewareStack<Input, Output>;
+    readonly schema?: OperationSchema | StaticOperationSchema;
+    /**
+     * Factory for Command ClassBuilder.
+     * @internal
+     */
+    static classBuilder<I extends SI, O extends SO, C extends {
+        logger?: Logger;
+        requestHandler: RequestHandler<any, any, any>;
+    }, SI extends object = any, SO extends MetadataBearer = any>(): ClassBuilder<I, O, C, SI, SO>;
+    abstract resolveMiddleware(stack: IMiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedClientConfiguration, options: any): Handler<Input, Output>;
+    /**
+     * @internal
+     */
+    resolveMiddlewareWithContext(clientStack: IMiddlewareStack<any, any>, configuration: {
+        logger?: Logger;
+        requestHandler: RequestHandler<any, any, any>;
+    }, options: any, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }: ResolveMiddlewareContextArgs): import("@smithy/types").InitializeHandler<any, Output>;
+}
+/**
+ * @internal
+ */
+type ResolveMiddlewareContextArgs = {
+    middlewareFn: (CommandCtor: any, clientStack: any, config: any, options: any) => Pluggable<any, any>[];
+    clientName: string;
+    commandName: string;
+    smithyContext: Record<string, unknown>;
+    additionalContext: HandlerExecutionContext;
+    inputFilterSensitiveLog: (_: any) => any;
+    outputFilterSensitiveLog: (_: any) => any;
+    CommandCtor: any;
+};
+/**
+ * @internal
+ */
+declare class ClassBuilder<I extends SI, O extends SO, C extends {
+    logger?: Logger;
+    requestHandler: RequestHandler<any, any, any>;
+}, SI extends object = any, SO extends MetadataBearer = any> {
+    private _init;
+    private _ep;
+    private _middlewareFn;
+    private _commandName;
+    private _clientName;
+    private _additionalContext;
+    private _smithyContext;
+    private _inputFilterSensitiveLog;
+    private _outputFilterSensitiveLog;
+    private _serializer;
+    private _deserializer;
+    private _operationSchema?;
+    /**
+     * Optional init callback.
+     */
+    init(cb: (_: Command<I, O, C, SI, SO>) => void): void;
+    /**
+     * Set the endpoint parameter instructions.
+     */
+    ep(endpointParameterInstructions: EndpointParameterInstructions): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Add any number of middleware.
+     */
+    m(middlewareSupplier: (CommandCtor: any, clientStack: any, config: any, options: any) => Pluggable<any, any>[]): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the initial handler execution context Smithy field.
+     */
+    s(service: string, operation: string, smithyContext?: Record<string, unknown>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the initial handler execution context.
+     */
+    c(additionalContext?: HandlerExecutionContext): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set constant string identifiers for the operation.
+     */
+    n(clientName: string, commandName: string): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the input and output sensistive log filters.
+     */
+    f(inputFilter?: (_: any) => any, outputFilter?: (_: any) => any): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Sets the serializer.
+     */
+    ser(serializer: (input: I, context?: SerdeContext | any) => Promise<IHttpRequest>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Sets the deserializer.
+     */
+    de(deserializer: (output: IHttpResponse, context?: SerdeContext | any) => Promise<O>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Sets input/output schema for the operation.
+     */
+    sc(operation: OperationSchema | StaticOperationSchema): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * @returns a Command class with the classBuilder properties.
+     */
+    build(): {
+        new (input: I): CommandImpl<I, O, C, SI, SO>;
+        new (...[input]: OptionalParameter<I>): CommandImpl<I, O, C, SI, SO>;
+        getEndpointParameterInstructions(): EndpointParameterInstructions;
+    };
+}
+/**
+ * A concrete implementation of ICommand with no abstract members.
+ * @public
+ */
+export interface CommandImpl<I extends SI, O extends SO, C extends {
+    logger?: Logger;
+    requestHandler: RequestHandler<any, any, any>;
+}, SI extends object = any, SO extends MetadataBearer = any> extends Command<I, O, C, SI, SO> {
+    readonly input: I;
+    resolveMiddleware(stack: IMiddlewareStack<SI, SO>, configuration: C, options: any): Handler<I, O>;
+}
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const SENSITIVE_STRING = "***SensitiveInformation***";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/create-aggregated-client.d.ts

@@ -0,0 +1,16 @@
+import { Client } from "./client";
+/**
+ * @internal
+ *
+ * @param commands - command lookup container.
+ * @param Client - client instance on which to add aggregated methods.
+ * @param options - paginator and waiter functions.
+ *
+ * @returns an aggregated client with dynamically created methods.
+ */
+export declare const createAggregatedClient: (commands: Record<string, any>, Client: {
+    new (...args: any): Client<any, any, any, any>;
+}, options?: {
+    paginators?: Record<string, any>;
+    waiters?: Record<string, any>;
+}) => void;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/default-error-handler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Always throws an error with the given `exceptionCtor` and other arguments.
+ * This is only called from an error handling code path.
+ *
+ * @internal
+ */
+export declare const throwDefaultError: ({ output, parsedBody, exceptionCtor, errorCode }: any) => never;
+/**
+ * Creates {@link throwDefaultError} with bound ExceptionCtor.
+ *
+ * @internal
+ */
+export declare const withBaseException: (ExceptionCtor: {
+    new (...args: any): any;
+}) => any;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/defaults-mode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @internal
+ */
+export declare const loadConfigsForDefaultMode: (mode: ResolvedDefaultsMode) => DefaultsModeConfigs;
+/**
+ * Option determining how certain default configuration options are resolved in the SDK. It can be one of the value listed below:
+ * * `"standard"`: <p>The STANDARD mode provides the latest recommended default values that should be safe to run in most scenarios</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"in-region"`: <p>The IN_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services from within the same AWS region</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"cross-region"`: <p>The CROSS_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services in a different region</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"mobile"`: <p>The MOBILE mode builds on the standard mode and includes optimization tailored for mobile applications</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"auto"`: <p>The AUTO mode is an experimental mode that builds on the standard mode. The SDK will attempt to discover the execution environment to determine the appropriate settings automatically.</p><p>Note that the auto detection is heuristics-based and does not guarantee 100% accuracy. STANDARD mode will be used if the execution environment cannot be determined. The auto detection might query <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html">EC2 Instance Metadata service</a>, which might introduce latency. Therefore we recommend choosing an explicit defaults_mode instead if startup latency is critical to your application</p>
+ * * `"legacy"`: <p>The LEGACY mode provides default settings that vary per SDK and were used prior to establishment of defaults_mode</p>
+ *
+ * @defaultValue "legacy"
+ */
+export type DefaultsMode = "standard" | "in-region" | "cross-region" | "mobile" | "auto" | "legacy";
+/**
+ * @internal
+ */
+export type ResolvedDefaultsMode = Exclude<DefaultsMode, "auto">;
+/**
+ * @internal
+ */
+export interface DefaultsModeConfigs {
+    retryMode?: string;
+    connectionTimeout?: number;
+    requestTimeout?: number;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/emitWarningIfUnsupportedVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Emits warning if the provided Node.js version string is pending deprecation.
+ *
+ * @internal
+ * @param version - The Node.js version string.
+ */
+export declare const emitWarningIfUnsupportedVersion: (version: string) => void;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/exceptions.d.ts

@@ -0,0 +1,42 @@
+import { HttpResponse, MetadataBearer, ResponseMetadata, RetryableTrait, SmithyException } from "@smithy/types";
+/**
+ * The type of the exception class constructor parameter. The returned type contains the properties
+ * in the `ExceptionType` but not in the `BaseExceptionType`. If the `BaseExceptionType` contains
+ * `$metadata` and `message` properties, it's also included in the returned type.
+ * @internal
+ */
+export type ExceptionOptionType<ExceptionType extends Error, BaseExceptionType extends Error> = Pick<ExceptionType, Exclude<keyof ExceptionType, Exclude<keyof BaseExceptionType, "$metadata" | "message">>>;
+/**
+ * @public
+ */
+export interface ServiceExceptionOptions extends SmithyException, MetadataBearer {
+    message?: string;
+}
+/**
+ * Base exception class for the exceptions from the server-side.
+ *
+ * @public
+ */
+export declare class ServiceException extends Error implements SmithyException, MetadataBearer {
+    readonly $fault: "client" | "server";
+    $response?: HttpResponse;
+    $retryable?: RetryableTrait;
+    $metadata: ResponseMetadata;
+    constructor(options: ServiceExceptionOptions);
+    /**
+     * Checks if a value is an instance of ServiceException (duck typed)
+     */
+    static isInstance(value: unknown): value is ServiceException;
+    /**
+     * Custom instanceof check to support the operator for ServiceException base class
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+/**
+ * This method inject unmodeled member to a deserialized SDK exception,
+ * and load the error message from different possible keys('message',
+ * 'Message').
+ *
+ * @internal
+ */
+export declare const decorateServiceException: <E extends ServiceException>(exception: E, additions?: Record<string, any>) => E;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/extensions/checksum.d.ts

@@ -0,0 +1,25 @@
+import { AlgorithmId, ChecksumAlgorithm, ChecksumConfiguration, ChecksumConstructor, HashConstructor } from "@smithy/types";
+export { AlgorithmId, ChecksumAlgorithm, ChecksumConfiguration };
+/**
+ * @internal
+ */
+export type PartialChecksumRuntimeConfigType = {
+    checksumAlgorithms?: Record<string, ChecksumConstructor | HashConstructor>;
+    sha256?: ChecksumConstructor | HashConstructor;
+    md5?: ChecksumConstructor | HashConstructor;
+    crc32?: ChecksumConstructor | HashConstructor;
+    crc32c?: ChecksumConstructor | HashConstructor;
+    sha1?: ChecksumConstructor | HashConstructor;
+};
+/**
+ * @param runtimeConfig - config object of the client instance.
+ * @internal
+ */
+export declare const getChecksumConfiguration: (runtimeConfig: PartialChecksumRuntimeConfigType) => {
+    addChecksumAlgorithm(algo: ChecksumAlgorithm): void;
+    checksumAlgorithms(): ChecksumAlgorithm[];
+};
+/**
+ * @internal
+ */
+export declare const resolveChecksumRuntimeConfig: (clientConfig: ChecksumConfiguration) => PartialChecksumRuntimeConfigType;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/extensions/defaultExtensionConfiguration.d.ts

@@ -0,0 +1,38 @@
+import { DefaultExtensionConfiguration } from "@smithy/types";
+import { PartialChecksumRuntimeConfigType } from "./checksum";
+import { PartialRetryRuntimeConfigType } from "./retry";
+/**
+ * @internal
+ */
+export type DefaultExtensionRuntimeConfigType = PartialRetryRuntimeConfigType & PartialChecksumRuntimeConfigType;
+/**
+ * Helper function to resolve default extension configuration from runtime config
+ *
+ * @internal
+ */
+export declare const getDefaultExtensionConfiguration: (runtimeConfig: DefaultExtensionRuntimeConfigType) => {
+    addChecksumAlgorithm(algo: import("@smithy/types").ChecksumAlgorithm): void;
+    checksumAlgorithms(): import("@smithy/types").ChecksumAlgorithm[];
+} & {
+    setRetryStrategy(retryStrategy: import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>): void;
+    retryStrategy(): import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>;
+};
+/**
+ * Helper function to resolve default extension configuration from runtime config
+ *
+ * @internal
+ * @deprecated use getDefaultExtensionConfiguration
+ */
+export declare const getDefaultClientConfiguration: (runtimeConfig: DefaultExtensionRuntimeConfigType) => {
+    addChecksumAlgorithm(algo: import("@smithy/types").ChecksumAlgorithm): void;
+    checksumAlgorithms(): import("@smithy/types").ChecksumAlgorithm[];
+} & {
+    setRetryStrategy(retryStrategy: import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>): void;
+    retryStrategy(): import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>;
+};
+/**
+ * Helper function to resolve runtime config from default extension configuration
+ *
+ * @internal
+ */
+export declare const resolveDefaultRuntimeConfig: (config: DefaultExtensionConfiguration) => DefaultExtensionRuntimeConfigType;