@rio-cloud/cdk-v2-constructs 8.4.0 → 8.6.0

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;

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

@@ -0,0 +1,18 @@
+import { Provider, RetryStrategy, RetryStrategyConfiguration, RetryStrategyV2 } from "@smithy/types";
+/**
+ * @internal
+ */
+export type PartialRetryRuntimeConfigType = Partial<{
+    retryStrategy: Provider<RetryStrategyV2 | RetryStrategy>;
+}>;
+/**
+ * @internal
+ */
+export declare const getRetryConfiguration: (runtimeConfig: PartialRetryRuntimeConfigType) => {
+    setRetryStrategy(retryStrategy: Provider<RetryStrategyV2 | RetryStrategy>): void;
+    retryStrategy(): Provider<RetryStrategyV2 | RetryStrategy>;
+};
+/**
+ * @internal
+ */
+export declare const resolveRetryRuntimeConfig: (retryStrategyConfiguration: RetryStrategyConfiguration) => PartialRetryRuntimeConfigType;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/get-array-if-single-item.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The XML parser will set one K:V for a member that could
+ * return multiple entries but only has one.
+ *
+ * @internal
+ */
+export declare const getArrayIfSingleItem: <T>(mayBeArray: T) => T | T[];

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/client/smithy-client/get-value-from-text-node.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Recursively parses object and populates value is node from
+ * "#text" key if it's available
+ *
+ * @internal
+ */
+export declare const getValueFromTextNode: (obj: any) => any;

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

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * @returns whether the header value is serializable.
+ */
+export declare const isSerializableHeaderValue: (value: any) => boolean;

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

@@ -0,0 +1,179 @@
+/**
+ * A set of instructions for multiple keys.
+ * The aim is to provide a concise yet readable way to map and filter values
+ * onto a target object.
+ *
+ * @example
+ * ```javascript
+ * const example: ObjectMappingInstructions = {
+ *   lazyValue1: [, () => 1],
+ *   lazyValue2: [, () => 2],
+ *   lazyValue3: [, () => 3],
+ *   lazyConditionalValue1: [() => true, () => 4],
+ *   lazyConditionalValue2: [() => true, () => 5],
+ *   lazyConditionalValue3: [true, () => 6],
+ *   lazyConditionalValue4: [false, () => 44],
+ *   lazyConditionalValue5: [() => false, () => 55],
+ *   lazyConditionalValue6: ["", () => 66],
+ *   simpleValue1: [, 7],
+ *   simpleValue2: [, 8],
+ *   simpleValue3: [, 9],
+ *   conditionalValue1: [() => true, 10],
+ *   conditionalValue2: [() => true, 11],
+ *   conditionalValue3: [{}, 12],
+ *   conditionalValue4: [false, 110],
+ *   conditionalValue5: [() => false, 121],
+ *   conditionalValue6: ["", 132],
+ * };
+ *
+ * const exampleResult: Record<string, any> = {
+ *   lazyValue1: 1,
+ *   lazyValue2: 2,
+ *   lazyValue3: 3,
+ *   lazyConditionalValue1: 4,
+ *   lazyConditionalValue2: 5,
+ *   lazyConditionalValue3: 6,
+ *   simpleValue1: 7,
+ *   simpleValue2: 8,
+ *   simpleValue3: 9,
+ *   conditionalValue1: 10,
+ *   conditionalValue2: 11,
+ *   conditionalValue3: 12,
+ * };
+ * ```
+ *
+ * @internal
+ */
+export type ObjectMappingInstructions = Record<string, ObjectMappingInstruction>;
+/**
+ * A variant of the object mapping instruction for the `take` function.
+ * In this case, the source value is provided to the value function, turning it
+ * from a supplier into a mapper.
+ *
+ * @internal
+ */
+export type SourceMappingInstructions = Record<string, ValueMapper | SourceMappingInstruction>;
+/**
+ * An instruction set for assigning a value to a target object.
+ *
+ * @internal
+ */
+export type ObjectMappingInstruction = LazyValueInstruction | ConditionalLazyValueInstruction | SimpleValueInstruction | ConditionalValueInstruction | UnfilteredValue;
+/**
+ * non-array
+ *
+ * @internal
+ */
+export type UnfilteredValue = any;
+/**
+ * @internal
+ */
+export type LazyValueInstruction = [
+    FilterStatus,
+    ValueSupplier
+];
+/**
+ * @internal
+ */
+export type ConditionalLazyValueInstruction = [
+    FilterStatusSupplier,
+    ValueSupplier
+];
+/**
+ * @internal
+ */
+export type SimpleValueInstruction = [
+    FilterStatus,
+    Value
+];
+/**
+ * @internal
+ */
+export type ConditionalValueInstruction = [
+    ValueFilteringFunction,
+    Value
+];
+/**
+ * @internal
+ */
+export type SourceMappingInstruction = [
+    (ValueFilteringFunction | FilterStatus)?,
+    ValueMapper?,
+    string?
+];
+/**
+ * Filter is considered passed if
+ * 1. It is a boolean true.
+ * 2. It is not undefined and is itself truthy.
+ * 3. It is undefined and the corresponding _value_ is neither null nor undefined.
+ *
+ * @internal
+ */
+export type FilterStatus = boolean | unknown | void;
+/**
+ * Supplies the filter check but not against any value as input.
+ *
+ * @internal
+ */
+export type FilterStatusSupplier = () => boolean;
+/**
+ * Filter check with the given value.
+ *
+ * @internal
+ */
+export type ValueFilteringFunction = (value: any) => boolean;
+/**
+ * Supplies the value for lazy evaluation.
+ *
+ * @internal
+ */
+export type ValueSupplier = () => any;
+/**
+ * A function that maps the source value to the target value.
+ * Defaults to pass-through with nullish check.
+ *
+ * @internal
+ */
+export type ValueMapper = (value: any) => any;
+/**
+ * A non-function value.
+ *
+ * @internal
+ */
+export type Value = any;
+/**
+ * Internal/Private, for codegen use only.
+ *
+ * Transfer a set of keys from [instructions] to [target].
+ *
+ * For each instruction in the record, the target key will be the instruction key.
+ * The target assignment will be conditional on the instruction's filter.
+ * The target assigned value will be supplied by the instructions as an evaluable function or non-function value.
+ *
+ * @see ObjectMappingInstructions for an example.
+ *
+ * @internal
+ */
+export declare function map(target: any, filter: (value: any) => boolean, instructions: Record<string, ValueSupplier | Value>): typeof target;
+/**
+ * @internal
+ */
+export declare function map(instructions: ObjectMappingInstructions): any;
+/**
+ * @internal
+ */
+export declare function map(target: any, instructions: ObjectMappingInstructions): typeof target;
+/**
+ * Convert a regular object `{ k: v }` to `{ k: [, v] }` mapping instruction set with default
+ * filter.
+ *
+ * @internal
+ */
+export declare const convertMap: (target: any) => Record<string, any>;
+/**
+ * @param source - original object with data.
+ * @param instructions - how to map the data.
+ * @returns new object mapped from the source object.
+ * @internal
+ */
+export declare const take: (source: any, instructions: SourceMappingInstructions) => any;

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

@@ -0,0 +1,9 @@
+import { SchemaRef } from "@smithy/types";
+/**
+ * Redacts sensitive parts of any data object using its schema, for logging.
+ *
+ * @internal
+ * @param schema - with filtering traits.
+ * @param data - to be logged.
+ */
+export declare function schemaLogFilter(schema: SchemaRef, data: unknown): any;

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

@@ -0,0 +1,14 @@
+/**
+ * Serializes a number, turning non-numeric values into strings.
+ *
+ * @internal
+ * @param value - The number to serialize.
+ * @returns A number, or a string if the given number was non-numeric.
+ */
+export declare const serializeFloat: (value: number) => string | number;
+/**
+ * @internal
+ * @param date - to be serialized.
+ * @returns https://smithy.io/2.0/spec/protocol-traits.html#timestampformat-trait date-time format.
+ */
+export declare const serializeDateTime: (date: Date) => string;

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

@@ -0,0 +1,10 @@
+/**
+ * Maps an object through the default JSON serde behavior.
+ * This means removing nullish fields and un-sparsifying lists.
+ * This is also used by Smithy RPCv2 CBOR as the default serde behavior.
+ *
+ * @internal
+ * @param obj - to be checked.
+ * @returns same object with default serde behavior applied.
+ */
+export declare const _json: (obj: any) => any;

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

@@ -0,0 +1,6 @@
+/**
+ * Helper for JSON stringification debug logging.
+ *
+ * @internal
+ */
+export declare const getCircularReplacer: () => (key: any, value: any) => any;

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

@@ -0,0 +1,11 @@
+import { WaiterOptions, WaiterResult } from "./waiter";
+/**
+ * Create a waiter promise that only resolves when:
+ * 1. Abort controller is signaled
+ * 2. Max wait time is reached
+ * 3. `acceptorChecks` succeeds, or fails
+ * Otherwise, it invokes `acceptorChecks` with exponential-backoff delay.
+ *
+ * @internal
+ */
+export declare const createWaiter: <Client, Input, Reason = any>(options: WaiterOptions<Client>, input: Input, acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult<Reason>>) => Promise<WaiterResult<Reason>>;