@cdklabs/cdk-ecs-codedeploy 0.0.441 → 0.0.443

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js

@@ -0,0 +1,48 @@
+import { Writable } from "node:stream";
+class Collector extends Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
+    }
+}
+const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}
+export const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
+        return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            resolve(bytes);
+        });
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.js

@@ -0,0 +1,5 @@
+import { fromString } from "../util-buffer-from/buffer-from";
+export const fromUtf8 = (input) => {
+    const buf = fromString(input, "utf8");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.browser.js

@@ -0,0 +1,10 @@
+import { fromUtf8 } from "./fromUtf8.browser";
+export const toUint8Array = (data) => {
+    if (typeof data === "string") {
+        return fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.js

@@ -0,0 +1,10 @@
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
+export const toUtf8 = (input) => {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/uuid/v4.js

@@ -0,0 +1,32 @@
+const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+export function bindV4(getRandomValues) {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return () => crypto.randomUUID();
+    }
+    return () => {
+        const rnds = new Uint8Array(16);
+        getRandomValues(rnds);
+        rnds[6] = (rnds[6] & 0x0f) | 0x40;
+        rnds[8] = (rnds[8] & 0x3f) | 0x80;
+        return (decimalToHex[rnds[0]] +
+            decimalToHex[rnds[1]] +
+            decimalToHex[rnds[2]] +
+            decimalToHex[rnds[3]] +
+            "-" +
+            decimalToHex[rnds[4]] +
+            decimalToHex[rnds[5]] +
+            "-" +
+            decimalToHex[rnds[6]] +
+            decimalToHex[rnds[7]] +
+            "-" +
+            decimalToHex[rnds[8]] +
+            decimalToHex[rnds[9]] +
+            "-" +
+            decimalToHex[rnds[10]] +
+            decimalToHex[rnds[11]] +
+            decimalToHex[rnds[12]] +
+            decimalToHex[rnds[13]] +
+            decimalToHex[rnds[14]] +
+            decimalToHex[rnds[15]]);
+    };
+}

package/node_modules/@smithy/core/dist-es/submodules/transport/index.js

@@ -0,0 +1,9 @@
+export { getSmithyContext } from "./getSmithyContext";
+export { HttpRequest } from "./httpRequest";
+export { HttpResponse } from "./httpResponse";
+export { isValidHostLabel } from "./isValidHostLabel";
+export { isValidHostname } from "./isValidHostname";
+export { normalizeProvider } from "./normalizeProvider";
+export { parseQueryString } from "./parseQueryString";
+export { parseUrl } from "./parseUrl";
+export { toEndpointV1 } from "./toEndpointV1";

package/node_modules/@smithy/core/dist-es/submodules/transport/parseUrl.js

@@ -0,0 +1,18 @@
+import { parseQueryString } from "./parseQueryString";
+export const parseUrl = (url) => {
+    if (typeof url === "string") {
+        return parseUrl(new URL(url));
+    }
+    const { hostname, pathname, port, protocol, search } = url;
+    let query;
+    if (search) {
+        query = parseQueryString(search);
+    }
+    return {
+        hostname,
+        port: port ? parseInt(port) : undefined,
+        protocol,
+        path: pathname,
+        query,
+    };
+};

package/node_modules/@smithy/core/dist-es/submodules/transport/toEndpointV1.js

@@ -0,0 +1,17 @@
+import { parseUrl } from "./parseUrl";
+export const toEndpointV1 = (endpoint) => {
+    if (typeof endpoint === "object") {
+        if ("url" in endpoint) {
+            const v1Endpoint = parseUrl(endpoint.url);
+            if (endpoint.headers) {
+                v1Endpoint.headers = {};
+                for (const name in endpoint.headers) {
+                    v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
+                }
+            }
+            return v1Endpoint;
+        }
+        return endpoint;
+    }
+    return parseUrl(endpoint);
+};

package/node_modules/@smithy/core/dist-types/index.d.ts

@@ -1,8 +1,12 @@
-export * from "./getSmithyContext";
-export * from "./middleware-http-auth-scheme";
-export * from "./middleware-http-signing";
+export { getSmithyContext } from "@smithy/core/transport";
+export * from "./legacy-root-exports/middleware-http-auth-scheme";
+export * from "./legacy-root-exports/middleware-http-signing";
 export * from "./normalizeProvider";
-export { createPaginator } from "./pagination/createPaginator";
-export * from "./request-builder/requestBuilder";
+export { createPaginator } from "./legacy-root-exports/pagination/createPaginator";
+/**
+ * Backwards compatibility re-export.
+ * @internal
+ */
+export { requestBuilder } from "@smithy/core/protocols";
 export * from "./setFeature";
-export * from "./util-identity-and-auth";
+export * from "./legacy-root-exports/util-identity-and-auth";

package/node_modules/@smithy/core/dist-types/legacy-root-exports/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { type PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeEndpointRuleSetMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+interface HttpAuthSchemeEndpointRuleSetPluginOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+export declare const getHttpAuthSchemeEndpointRuleSetPlugin: <TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object>(config: TConfig & PreviouslyResolved<TParameters>, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }: HttpAuthSchemeEndpointRuleSetPluginOptions<TConfig, TContext, TParameters, TInput>) => Pluggable<any, any>;
+export {};

package/node_modules/@smithy/core/dist-types/legacy-root-exports/middleware-http-auth-scheme/getHttpAuthSchemePlugin.d.ts

@@ -0,0 +1,18 @@
+import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { type PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+interface HttpAuthSchemePluginOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+export declare const getHttpAuthSchemePlugin: <TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object>(config: TConfig & PreviouslyResolved<TParameters>, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }: HttpAuthSchemePluginOptions<TConfig, TContext, TParameters, TInput>) => Pluggable<any, any>;
+export {};

package/node_modules/@smithy/core/dist-types/legacy-root-exports/middleware-http-auth-scheme/httpAuthSchemeMiddleware.d.ts

@@ -0,0 +1,33 @@
+import type { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SMITHY_CONTEXT_KEY, SelectedHttpAuthScheme, SerializeMiddleware } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface PreviouslyResolved<TParameters extends HttpAuthSchemeParameters> {
+    authSchemePreference?: Provider<string[]>;
+    httpAuthSchemes: HttpAuthScheme[];
+    httpAuthSchemeProvider: HttpAuthSchemeProvider<TParameters>;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareSmithyContext extends Record<string, unknown> {
+    selectedHttpAuthScheme?: SelectedHttpAuthScheme;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareHandlerExecutionContext extends HandlerExecutionContext {
+    [SMITHY_CONTEXT_KEY]?: HttpAuthSchemeMiddlewareSmithyContext;
+}
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeMiddleware: <TInput extends object, Output extends object, TConfig extends object, TContext extends HttpAuthSchemeMiddlewareHandlerExecutionContext, TParameters extends HttpAuthSchemeParameters>(config: TConfig & PreviouslyResolved<TParameters>, mwOptions: HttpAuthSchemeMiddlewareOptions<TConfig, TContext, TParameters, TInput>) => SerializeMiddleware<TInput, Output>;
+export {};

package/node_modules/@smithy/core/dist-types/legacy-root-exports/pagination/createPaginator.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationConfiguration, Paginator } from "@smithy/types";
+/**
+ * Creates a paginator.
+ *
+ * @internal
+ */
+export declare function createPaginator<PaginationConfigType extends PaginationConfiguration, InputType extends object, OutputType extends object>(ClientCtor: any, CommandCtor: any, inputTokenName: string, outputTokenName: string, pageSizeTokenName?: string): (config: PaginationConfigType, input: InputType, ...additionalArguments: any[]) => Paginator<OutputType>;

package/node_modules/@smithy/core/dist-types/legacy-root-exports/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.d.ts

@@ -0,0 +1,8 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { type ApiKeyIdentity, type HttpSigner, type HttpRequest as IHttpRequest } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class HttpApiKeyAuthSigner implements HttpSigner {
+    sign(httpRequest: HttpRequest, identity: ApiKeyIdentity, signingProperties: Record<string, any>): Promise<IHttpRequest>;
+}

package/node_modules/@smithy/core/dist-types/legacy-root-exports/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.d.ts

@@ -0,0 +1,8 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import type { HttpSigner, HttpRequest as IHttpRequest, TokenIdentity } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class HttpBearerAuthSigner implements HttpSigner {
+    sign(httpRequest: HttpRequest, identity: TokenIdentity, signingProperties: Record<string, any>): Promise<IHttpRequest>;
+}

package/node_modules/@smithy/core/dist-types/legacy-root-exports/util-identity-and-auth/memoizeIdentityProvider.d.ts

@@ -0,0 +1,31 @@
+import type { Identity, IdentityProvider } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const createIsIdentityExpiredFunction: (expirationMs: number) => (identity: Identity) => boolean;
+/**
+ * This may need to be configurable in the future, but for now it is defaulted to 5min.
+ *
+ * @internal
+ */
+export declare const EXPIRATION_MS = 300000;
+/**
+ * @internal
+ */
+export declare const isIdentityExpired: (identity: Identity) => boolean;
+/**
+ * @internal
+ */
+export declare const doesIdentityRequireRefresh: (identity: Identity) => boolean;
+/**
+ * @internal
+ */
+export interface MemoizedIdentityProvider<IdentityT extends Identity> {
+    (options?: Record<string, any> & {
+        forceRefresh?: boolean;
+    }): Promise<IdentityT>;
+}
+/**
+ * @internal
+ */
+export declare const memoizeIdentityProvider: <IdentityT extends Identity>(provider: IdentityT | IdentityProvider<IdentityT> | undefined, isExpired: (resolved: Identity) => boolean, requiresRefresh: (resolved: Identity) => boolean) => MemoizedIdentityProvider<IdentityT> | undefined;

package/node_modules/@smithy/core/dist-types/setFeature.d.ts

@@ -1,12 +1,12 @@
 import type { HandlerExecutionContext, SmithyFeatures } from "@smithy/types";
 /**
- * @internal
  * Indicates to the request context that a given feature is active.
+ * specification asks the library not to include a runtime lookup of all
+ * the feature identifiers.
  *
+ * @internal
  * @param context - handler execution context.
  * @param feature - readable name of feature.
  * @param value - encoding value of feature. This is required because the
- * specification asks the library not to include a runtime lookup of all
- * the feature identifiers.
  */
 export declare function setFeature<F extends keyof SmithyFeatures>(context: HandlerExecutionContext, feature: F, value: SmithyFeatures[F]): void;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-decode.d.ts

@@ -1,14 +1,15 @@
-import type { CborValueType, Float32, Uint8, Uint32 } from "./cbor-types";
+import { type CborValueType, type Float32, type Uint8, type Uint32 } from "./cbor-types";
 /**
+ * Sets the decode bytearray source and its data view.
+ *
  * @internal
  * @param bytes - to be set as the decode source.
- *
- * Sets the decode bytearray source and its data view.
  */
 export declare function setPayload(bytes: Uint8Array): void;
 /**
- * @internal
  * Decodes the data between the two indices.
+ *
+ * @internal
  */
 export declare function decode(at: Uint32, to: Uint32): CborValueType;
 /**

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-types.d.ts

@@ -39,17 +39,17 @@ export declare const extendedFloat64 = 27;
 export declare const minorIndefinite = 31;
 export declare function alloc(size: number): Uint8Array;
 /**
- * @public
- *
  * The presence of this symbol as an object key indicates it should be considered a tag
  * for CBOR serialization purposes.
- *
  * The object must also have the properties "tag" and "value".
+ *
+ * @public
  */
 export declare const tagSymbol: unique symbol;
 /**
- * @public
  * Applies the tag symbol to the object.
+ *
+ * @public
  */
 export declare function tag(data: {
     tag: number | bigint;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor.d.ts

@@ -12,15 +12,14 @@ export declare const cbor: {
     deserialize(payload: Uint8Array): any;
     serialize(input: any): Uint8Array;
     /**
-     * @public
-     * @param size - byte length to allocate.
-     *
      * This may be used to garbage collect the CBOR
      * shared encoding buffer space,
      * e.g. resizeEncodingBuffer(0);
-     *
      * This may also be used to pre-allocate more space for
      * CBOR encoding, e.g. resizeEncodingBuffer(100_000_000);
+     *
+     * @public
+     * @param size - byte length to allocate.
      */
     resizeEncodingBuffer(size: number): void;
 };

package/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

@@ -1,6 +1,6 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import type { HeaderBag as __HeaderBag, HttpResponse, SerdeContext as __SerdeContext, SerdeContext } from "@smithy/types";
-import type { tagSymbol } from "./cbor-types";
+import { HttpRequest as __HttpRequest } from "@smithy/core/protocols";
+import type { HttpResponse, SerdeContext, HeaderBag as __HeaderBag, SerdeContext as __SerdeContext } from "@smithy/types";
+import { type tagSymbol } from "./cbor-types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/submodules/checksum/chunked-blob-reader/chunked-blob-reader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the blob data into the onChunk consumer.
+ *
+ * @internal
+ */
+export declare function blobReader(blob: Blob, onChunk: (chunk: Uint8Array) => void, chunkSize?: number): Promise<void>;

package/node_modules/@smithy/core/dist-types/submodules/checksum/chunked-blob-reader/chunked-blob-reader.native.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function blobReader(blob: Blob, onChunk: (chunk: Uint8Array) => void, chunkSize?: number): Promise<void>;

package/node_modules/@smithy/core/dist-types/submodules/checksum/hash-blob-browser/blobHasher.d.ts

@@ -0,0 +1,5 @@
+import type { StreamHasher } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const blobHasher: StreamHasher<Blob>;

package/node_modules/@smithy/core/dist-types/submodules/checksum/hash-stream-node/HashCalculator.d.ts

@@ -0,0 +1,10 @@
+import { Writable, type WritableOptions } from "node:stream";
+import type { Checksum, Hash } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class HashCalculator extends Writable {
+    readonly hash: Checksum | Hash;
+    constructor(hash: Checksum | Hash, options?: WritableOptions);
+    _write(chunk: Buffer, encoding: string, callback: (err?: Error) => void): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/checksum/hash-stream-node/fileStreamHasher.d.ts

@@ -0,0 +1,6 @@
+import type { Readable } from "node:stream";
+import type { StreamHasher } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const fileStreamHasher: StreamHasher<Readable>;

package/node_modules/@smithy/core/dist-types/submodules/checksum/hash-stream-node/readableStreamHasher.d.ts

@@ -0,0 +1,6 @@
+import type { Readable } from "node:stream";
+import type { StreamHasher } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const readableStreamHasher: StreamHasher<Readable>;

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

@@ -0,0 +1,5 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export declare const fileStreamHasher: symbol;
+export declare const readableStreamHasher: symbol;
+export { Md5 } from "./md5-js/md5";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

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

@@ -0,0 +1,5 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export { fileStreamHasher } from "./hash-stream-node/fileStreamHasher";
+export { readableStreamHasher } from "./hash-stream-node/readableStreamHasher";
+export { Md5 } from "./md5-js/md5";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

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

@@ -0,0 +1,5 @@
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export declare const fileStreamHasher: symbol;
+export declare const readableStreamHasher: symbol;
+export { Md5 } from "./md5-js/md5";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader.native";

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5-js/constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @internal
+ */
+export declare const BLOCK_SIZE = 64;
+/**
+ * @internal
+ */
+export declare const DIGEST_LENGTH = 16;
+/**
+ * @internal
+ */
+export declare const INIT: number[];

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5-js/md5.d.ts

@@ -0,0 +1,16 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class Md5 implements Checksum {
+    private state;
+    private buffer;
+    private bufferLength;
+    private bytesHashed;
+    private finished;
+    constructor();
+    update(sourceData: SourceData): void;
+    digest(): Promise<Uint8Array>;
+    private hashBuffer;
+    reset(): void;
+}

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

@@ -0,0 +1,26 @@
+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, type WaiterConfiguration, type WaiterOptions, type WaiterResult, } from "./util-waiter/waiter";
+export { Client, type SmithyConfiguration, type SmithyResolvedConfiguration } from "./smithy-client/client";
+export { Command, type 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, type DefaultsMode, type ResolvedDefaultsMode, type DefaultsModeConfigs, } from "./smithy-client/defaults-mode";
+export { emitWarningIfUnsupportedVersion } from "./smithy-client/emitWarningIfUnsupportedVersion";
+export { ServiceException, decorateServiceException, type ExceptionOptionType, type ServiceExceptionOptions, } from "./smithy-client/exceptions";
+export { getDefaultExtensionConfiguration, getDefaultClientConfiguration, resolveDefaultRuntimeConfig, type DefaultExtensionRuntimeConfigType, } from "./smithy-client/extensions/defaultExtensionConfiguration";
+export { AlgorithmId, getChecksumConfiguration, resolveChecksumRuntimeConfig, type ChecksumAlgorithm, type ChecksumConfiguration, type PartialChecksumRuntimeConfigType, } from "./smithy-client/extensions/checksum";
+export { getRetryConfiguration, resolveRetryRuntimeConfig, type 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, type ObjectMappingInstructions, type SourceMappingInstructions, type ObjectMappingInstruction, type UnfilteredValue, type LazyValueInstruction, type ConditionalLazyValueInstruction, type SimpleValueInstruction, type ConditionalValueInstruction, type SourceMappingInstruction, type FilterStatus, type FilterStatusSupplier, type ValueFilteringFunction, type ValueSupplier, type ValueMapper, type 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";

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

@@ -0,0 +1,84 @@
+import type { $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;
+}