@cdklabs/cdk-ecs-codedeploy 0.0.445 → 0.0.447

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

@@ -21,6 +21,7 @@ export { calculateBodyLength } from "./util-body-length/calculateBodyLength.brow
 export { fromUtf8 } from "./util-utf8/fromUtf8.browser";
 export { toUint8Array } from "./util-utf8/toUint8Array.browser";
 export { toUtf8 } from "./util-utf8/toUtf8.browser";
+export { concatBytes } from "./concatBytes";
 export const fromArrayBuffer = no;
 export const fromString = no;
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
@@ -38,6 +39,7 @@ export { headStream } from "./util-stream/headStream.browser";
 export { sdkStreamMixin } from "./util-stream/sdk-stream-mixin.browser";
 export { splitStream } from "./util-stream/splitStream.browser";
 export { isReadableStream, isBlob } from "./util-stream/stream-type-check";
+export { streamCollector } from "./util-stream/stream-collector.browser";
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;

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

@@ -1,60 +1,68 @@
-import { Duplex } from "node:stream";
+import { Readable } from "node:stream";
 import { toBase64 } from "../../util-base64/toBase64";
-export class ChecksumStream extends Duplex {
+export class ChecksumStream extends Readable {
     expectedChecksum;
     checksumSourceLocation;
     checksum;
     source;
     base64Encoder;
-    pendingCallback = null;
     constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) {
         super();
-        if (typeof source.pipe === "function") {
-            this.source = source;
-        }
-        else {
+        if (typeof source.pipe !== "function") {
             throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
         }
+        this.source = source;
         this.base64Encoder = base64Encoder ?? toBase64;
         this.expectedChecksum = expectedChecksum;
         this.checksum = checksum;
         this.checksumSourceLocation = checksumSourceLocation;
-        this.source.pipe(this);
+        this.source.on("data", this.onSourceData);
+        this.source.on("end", this.onSourceEnd);
+        this.source.on("error", this.onSourceError);
+        this.source.pause();
     }
-    _read(size) {
-        if (this.pendingCallback) {
-            const callback = this.pendingCallback;
-            this.pendingCallback = null;
-            callback();
+    onSourceData = (chunk) => {
+        if (this.destroyed) {
+            return;
         }
-    }
-    _write(chunk, encoding, callback) {
         try {
             this.checksum.update(chunk);
-            const canPushMore = this.push(chunk);
-            if (!canPushMore) {
-                this.pendingCallback = callback;
-                return;
-            }
         }
         catch (e) {
-            return callback(e);
+            this.destroy(e);
+            return;
+        }
+        if (!this.push(chunk)) {
+            this.source.pause();
+        }
+    };
+    onSourceEnd = async () => {
+        if (this.destroyed) {
+            return;
         }
-        return callback();
-    }
-    async _final(callback) {
         try {
             const digest = await this.checksum.digest();
             const received = this.base64Encoder(digest);
             if (this.expectedChecksum !== received) {
-                return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
+                this.destroy(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
                     ` in response header "${this.checksumSourceLocation}".`));
+                return;
             }
         }
         catch (e) {
-            return callback(e);
+            this.destroy(e);
+            return;
         }
         this.push(null);
-        return callback();
+    };
+    onSourceError = (error) => {
+        this.destroy(error);
+    };
+    _read(size) {
+        this.source.resume();
+    }
+    _destroy(error, callback) {
+        this.source?.destroy();
+        callback(error);
     }
 }

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

@@ -1,4 +1,5 @@
 import { Writable } from "node:stream";
+import { concatBytes } from "../concatBytes";
 import { headStream as headWebStream } from "./headStream.browser";
 import { isReadableStream } from "./stream-type-check";
 export const headStream = (stream, bytes) => {
@@ -15,7 +16,7 @@ export const headStream = (stream, bytes) => {
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = new Uint8Array(Buffer.concat(this.buffers));
+            const bytes = concatBytes(this.buffers);
             resolve(bytes);
         });
     });

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

@@ -1,53 +1,27 @@
-import { fromBase64 } from "../util-base64/fromBase64.browser";
+import { concatBytes } from "../concatBytes";
+import { isBlob } from "./stream-type-check";
 export const streamCollector = async (stream) => {
-    if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
-        if (Blob.prototype.arrayBuffer !== undefined) {
-            return new Uint8Array(await stream.arrayBuffer());
-        }
+    if (isBlob(stream)) {
         return collectBlob(stream);
     }
-    return collectStream(stream);
+    return collectReadableStream(stream);
 };
-async function collectBlob(blob) {
-    const base64 = await readToBase64(blob);
-    const arrayBuffer = fromBase64(base64);
-    return new Uint8Array(arrayBuffer);
+export async function collectBlob(blob) {
+    return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
 }
-async function collectStream(stream) {
+export async function collectReadableStream(stream) {
     const chunks = [];
     const reader = stream.getReader();
-    let isDone = false;
     let length = 0;
-    while (!isDone) {
+    while (true) {
         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;
+        if (done) {
+            break;
+        }
     }
-    return collected;
-}
-function readToBase64(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-            if (reader.readyState !== 2) {
-                return reject(new Error("Reader aborted too early"));
-            }
-            const result = (reader.result ?? "");
-            const commaIndex = result.indexOf(",");
-            const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-            resolve(result.substring(dataOffset));
-        };
-        reader.onabort = () => reject(new Error("Read aborted"));
-        reader.onerror = () => reject(reader.error);
-        reader.readAsDataURL(blob);
-    });
+    return concatBytes(chunks, length);
 }

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

@@ -1,48 +1,33 @@
 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;
-}
+import { concatBytes } from "../concatBytes";
+import { collectBlob, collectReadableStream } from "./stream-collector.browser";
+import { isBlob, isReadableStream } from "./stream-type-check";
 export const streamCollector = (stream) => {
-    if (isReadableStreamInstance(stream)) {
+    if (isBlob(stream)) {
+        return collectBlob(stream);
+    }
+    if (isReadableStream(stream)) {
         return collectReadableStream(stream);
     }
     return new Promise((resolve, reject) => {
         const collector = new Collector();
-        stream.pipe(collector);
-        stream.on("error", (err) => {
+        const nodeStream = stream;
+        nodeStream.pipe(collector);
+        nodeStream.on("error", (err) => {
             collector.end();
             reject(err);
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            const bytes = concatBytes(this.bufferedBytes);
             resolve(bytes);
         });
     });
 };
+class Collector extends Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
+    }
+}

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

@@ -1,5 +1,8 @@
 import { fromUtf8 } from "./fromUtf8.browser";
 export const toUint8Array = (data) => {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
     if (typeof data === "string") {
         return fromUtf8(data);
     }

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

@@ -1,5 +1,8 @@
 import { fromUtf8 } from "./fromUtf8";
 export const toUint8Array = (data) => {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
     if (typeof data === "string") {
         return fromUtf8(data);
     }

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

@@ -0,0 +1,18 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * Pure JS CRC-32 implementation using the IEEE 802.3 polynomial.
+ * @see https://www.w3.org/TR/png/#D-CRCAppendix
+ * @public
+ */
+export declare class Crc32Js implements Checksum {
+    readonly digestLength = 4;
+    private checksum;
+    update(data: Uint8Array): void;
+    /**
+     * Used by EventStreamCodec.
+     * @internal
+     */
+    digestSync(): number;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

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

@@ -0,0 +1,18 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * CRC-32 using Node.js zlib native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Crc32Node extends Checksum {
+    readonly digestLength: 4;
+    /**
+     * Used by EventStreamCodec.
+     * @internal
+     */
+    digestSync(): number;
+}
+/**
+ * @public
+ */
+export declare const Crc32Node: new () => Crc32Node;

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

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export declare const fileStreamHasher: symbol;
 export declare const readableStreamHasher: symbol;
-export { Md5 } from "./md5-js/md5";
+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/submodules/checksum/index.d.ts

@@ -1,5 +1,11 @@
 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 { 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/submodules/checksum/index.native.d.ts

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export declare const fileStreamHasher: symbol;
 export declare const readableStreamHasher: symbol;
-export { Md5 } from "./md5-js/md5";
+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/submodules/checksum/md5/Md5Js.d.ts

@@ -0,0 +1,19 @@
+import type { 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/submodules/checksum/md5/Md5Node.d.ts

@@ -0,0 +1,17 @@
+import type { 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/submodules/checksum/sha256/Sha256Js.d.ts

@@ -0,0 +1,28 @@
+import type { 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/submodules/checksum/sha256/Sha256Node.d.ts

@@ -0,0 +1,13 @@
+import type { 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/submodules/checksum/sha256/Sha256WebCrypto.d.ts

@@ -0,0 +1,22 @@
+import type { 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/submodules/client/index.d.ts

@@ -24,3 +24,4 @@ export { map, convertMap, take, type ObjectMappingInstructions, type SourceMappi
 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/submodules/client/smithy-client/client-command-builder.d.ts

@@ -0,0 +1,22 @@
+import type { EndpointParameterInstructions, Logger, MetadataBearer, OptionalParameter, Pluggable, RequestHandler, StaticOperationSchema } from "@smithy/types";
+import { type 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/submodules/client/smithy-client/command.d.ts

@@ -1,5 +1,4 @@
-import { type Handler, type HandlerExecutionContext, type Command as ICommand, type HttpRequest as IHttpRequest, type HttpResponse as IHttpResponse, type MiddlewareStack as IMiddlewareStack, type Logger, type MetadataBearer, type OperationSchema, type OptionalParameter, type Pluggable, type RequestHandler, type SerdeContext, type StaticOperationSchema } from "@smithy/types";
-type EndpointParameterInstructions = Record<string, unknown>;
+import { type EndpointParameterInstructions, type Handler, type HandlerExecutionContext, type Command as ICommand, type HttpRequest as IHttpRequest, type HttpResponse as IHttpResponse, type MiddlewareStack as IMiddlewareStack, type Logger, type MetadataBearer, type OperationSchema, type OptionalParameter, type Pluggable, type RequestHandler, type SerdeContext, type StaticOperationSchema } from "@smithy/types";
 /**
  * @public
  */
@@ -12,7 +11,7 @@ export declare abstract class Command<Input extends ClientInput, Output extends
      * @internal
      */
     static classBuilder<I extends SI, O extends SO, C extends {
-        logger: Logger;
+        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>;
@@ -20,7 +19,7 @@ export declare abstract class Command<Input extends ClientInput, Output extends
      * @internal
      */
     resolveMiddlewareWithContext(clientStack: IMiddlewareStack<any, any>, configuration: {
-        logger: Logger;
+        logger?: Logger;
         requestHandler: RequestHandler<any, any, any>;
     }, options: any, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }: ResolveMiddlewareContextArgs): import("@smithy/types").InitializeHandler<any, Output>;
 }
@@ -41,7 +40,7 @@ type ResolveMiddlewareContextArgs = {
  * @internal
  */
 declare class ClassBuilder<I extends SI, O extends SO, C extends {
-    logger: Logger;
+    logger?: Logger;
     requestHandler: RequestHandler<any, any, any>;
 }, SI extends object = any, SO extends MetadataBearer = any> {
     private _init;
@@ -110,7 +109,7 @@ declare class ClassBuilder<I extends SI, O extends SO, C extends {
  * @public
  */
 export interface CommandImpl<I extends SI, O extends SO, C extends {
-    logger: Logger;
+    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;

package/node_modules/@smithy/core/dist-types/submodules/config/config-resolver/regionConfig/getInstanceMetadataRegion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the region of the host from the EC2 Instance Metadata Service (IMDSv2),
+ * or undefined if unavailable.
+ *
+ * @internal
+ */
+export declare const getInstanceMetadataRegion: () => Promise<string | undefined>;

package/node_modules/@smithy/core/dist-types/submodules/config/defaults-mode/constants.d.ts

@@ -22,3 +22,15 @@ export declare const DEFAULTS_MODE_OPTIONS: string[];
  * @internal
  */
 export declare const IMDS_REGION_PATH = "/latest/meta-data/placement/region";
+/**
+ * @internal
+ */
+export declare const IMDS_TOKEN_PATH = "/latest/api/token";
+/**
+ * @internal
+ */
+export declare const X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token";
+/**
+ * @internal
+ */
+export declare const X_AWS_EC2_METADATA_TOKEN_TTL = "x-aws-ec2-metadata-token-ttl-seconds";

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

@@ -7,18 +7,17 @@ export { isValidHostLabel } from "@smithy/core/transport";
 export { customEndpointFunctions } from "./util-endpoints/utils/customEndpointFunctions";
 export { resolveEndpoint } from "./util-endpoints/resolveEndpoint";
 export * from "./util-endpoints/types";
-export declare const getEndpointFromInstructions: <T extends import("@smithy/types").EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: import("./middleware-endpoint/adaptors/getEndpointFromInstructions").EndpointParameterInstructionsSupplier, clientConfig: Partial<import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>> & Config, context?: import("@smithy/types").HandlerExecutionContext) => Promise<import("@smithy/types").EndpointV2>;
+export declare const getEndpointFromInstructions: <T extends import("@smithy/types").EndpointParameters, CommandInput extends object, Config extends object>(commandInput: CommandInput, instructionsSupplier: import("./middleware-endpoint/adaptors/getEndpointFromInstructions").EndpointParameterInstructionsSupplier, clientConfig: Partial<import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>> & Config, context?: import("@smithy/types").HandlerExecutionContext) => Promise<import("@smithy/types").EndpointV2>;
 export declare const resolveEndpointConfig: <T, P extends import("@smithy/types").EndpointParameters = import("@smithy/types").EndpointParameters>(input: T & import("./middleware-endpoint/resolveEndpointConfig").EndpointInputConfig<P> & import("./middleware-endpoint/resolveEndpointConfig").PreviouslyResolved<P>) => T & import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<P>;
 export declare const endpointMiddleware: <T extends import("@smithy/types").EndpointParameters>({ config, instructions, }: {
     config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>;
-    instructions: import("./middleware-endpoint/types").EndpointParameterInstructions;
+    instructions: import("@smithy/types").EndpointParameterInstructions;
 }) => import("@smithy/types").SerializeMiddleware<any, any>;
-export declare const getEndpointPlugin: <T extends import("@smithy/types").EndpointParameters>(config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>, instructions: import("./middleware-endpoint/types").EndpointParameterInstructions) => import("@smithy/types").Pluggable<any, any>;
+export declare const getEndpointPlugin: <T extends import("@smithy/types").EndpointParameters>(config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>, instructions: import("@smithy/types").EndpointParameterInstructions) => import("@smithy/types").Pluggable<any, any>;
 export { resolveParams, type EndpointParameterInstructionsSupplier, } from "./middleware-endpoint/adaptors/getEndpointFromInstructions";
 export { toEndpointV1 as middlewareEndpointToEndpointV1 } from "./middleware-endpoint/adaptors/toEndpointV1";
 export { endpointMiddlewareOptions } from "./middleware-endpoint/getEndpointPlugin";
 export type { EndpointInputConfig, EndpointResolvedConfig } from "./middleware-endpoint/resolveEndpointConfig";
 export { resolveEndpointRequiredConfig } from "./middleware-endpoint/resolveEndpointRequiredConfig";
 export type { EndpointRequiredInputConfig, EndpointRequiredResolvedConfig, } from "./middleware-endpoint/resolveEndpointRequiredConfig";
-export type { EndpointParameterInstructions } from "./middleware-endpoint/types";
-export type { BuiltInParamInstruction, ClientContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, StaticContextParamInstruction, } from "./middleware-endpoint/types";
+export type { EndpointParameterInstructions, BuiltInParamInstruction, ClientContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, StaticContextParamInstruction, } from "@smithy/types";

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

@@ -7,18 +7,17 @@ export { isValidHostLabel } from "@smithy/core/transport";
 export { customEndpointFunctions } from "./util-endpoints/utils/customEndpointFunctions";
 export { resolveEndpoint } from "./util-endpoints/resolveEndpoint";
 export * from "./util-endpoints/types";
-export declare const getEndpointFromInstructions: <T extends import("@smithy/types").EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: import("./middleware-endpoint/adaptors/getEndpointFromInstructions").EndpointParameterInstructionsSupplier, clientConfig: Partial<import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>> & Config, context?: import("@smithy/types").HandlerExecutionContext) => Promise<import("@smithy/types").EndpointV2>;
+export declare const getEndpointFromInstructions: <T extends import("@smithy/types").EndpointParameters, CommandInput extends object, Config extends object>(commandInput: CommandInput, instructionsSupplier: import("./middleware-endpoint/adaptors/getEndpointFromInstructions").EndpointParameterInstructionsSupplier, clientConfig: Partial<import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>> & Config, context?: import("@smithy/types").HandlerExecutionContext) => Promise<import("@smithy/types").EndpointV2>;
 export declare const resolveEndpointConfig: <T, P extends import("@smithy/types").EndpointParameters = import("@smithy/types").EndpointParameters>(input: T & import("./middleware-endpoint/resolveEndpointConfig").EndpointInputConfig<P> & import("./middleware-endpoint/resolveEndpointConfig").PreviouslyResolved<P>) => T & import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<P>;
 export declare const endpointMiddleware: <T extends import("@smithy/types").EndpointParameters>({ config, instructions, }: {
     config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>;
-    instructions: import("./middleware-endpoint/types").EndpointParameterInstructions;
+    instructions: import("@smithy/types").EndpointParameterInstructions;
 }) => import("@smithy/types").SerializeMiddleware<any, any>;
-export declare const getEndpointPlugin: <T extends import("@smithy/types").EndpointParameters>(config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>, instructions: import("./middleware-endpoint/types").EndpointParameterInstructions) => import("@smithy/types").Pluggable<any, any>;
+export declare const getEndpointPlugin: <T extends import("@smithy/types").EndpointParameters>(config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>, instructions: import("@smithy/types").EndpointParameterInstructions) => import("@smithy/types").Pluggable<any, any>;
 export { resolveParams, type EndpointParameterInstructionsSupplier, } from "./middleware-endpoint/adaptors/getEndpointFromInstructions";
 export { toEndpointV1 as middlewareEndpointToEndpointV1 } from "./middleware-endpoint/adaptors/toEndpointV1";
 export { endpointMiddlewareOptions } from "./middleware-endpoint/getEndpointPlugin";
 export type { EndpointInputConfig, EndpointResolvedConfig } from "./middleware-endpoint/resolveEndpointConfig";
 export { resolveEndpointRequiredConfig } from "./middleware-endpoint/resolveEndpointRequiredConfig";
 export type { EndpointRequiredInputConfig, EndpointRequiredResolvedConfig, } from "./middleware-endpoint/resolveEndpointRequiredConfig";
-export type { EndpointParameterInstructions } from "./middleware-endpoint/types";
-export type { BuiltInParamInstruction, ClientContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, StaticContextParamInstruction, } from "./middleware-endpoint/types";
+export type { EndpointParameterInstructions, BuiltInParamInstruction, ClientContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, StaticContextParamInstruction, } from "@smithy/types";