@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

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

@@ -0,0 +1,8 @@
+import { HttpRequest, HttpSigner, Identity } from "@smithy/types";
+/**
+ * Signer for the synthetic @smithy.api#noAuth auth scheme.
+ * @internal
+ */
+export declare class NoAuthSigner implements HttpSigner {
+    sign(httpRequest: HttpRequest, identity: Identity, signingProperties: Record<string, unknown>): Promise<HttpRequest>;
+}

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

@@ -0,0 +1,4 @@
+export { DefaultIdentityProviderConfig } from "./DefaultIdentityProviderConfig";
+export { HttpApiKeyAuthSigner, HttpBearerAuthSigner, NoAuthSigner } from "./httpAuthSchemes";
+export { EXPIRATION_MS, createIsIdentityExpiredFunction, doesIdentityRequireRefresh, isIdentityExpired, memoizeIdentityProvider, } from "./memoizeIdentityProvider";
+export { MemoizedIdentityProvider } from "./memoizeIdentityProvider";

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

@@ -0,0 +1,31 @@
+import { 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/ts3.4/normalizeProvider.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "@smithy/types";
+/**
+ * @internal
+ *
+ * @returns a provider function for the input value if it isn't already one.
+ */
+export declare const normalizeProvider: <T>(input: T | Provider<T>) => Provider<T>;

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

@@ -0,0 +1,12 @@
+import { HandlerExecutionContext, SmithyFeatures } from "@smithy/types";
+/**
+ * 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
+ */
+export declare function setFeature<F extends keyof SmithyFeatures>(context: HandlerExecutionContext, feature: F, value: SmithyFeatures[F]): void;

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

@@ -0,0 +1,33 @@
+import { SerdeContext } from "@smithy/core/protocols";
+import { Codec, Schema, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+/**
+ * @public
+ */
+export declare class CborCodec extends SerdeContext implements Codec<Uint8Array, Uint8Array> {
+    createSerializer(): CborShapeSerializer;
+    createDeserializer(): CborShapeDeserializer;
+}
+/**
+ * @public
+ */
+export declare class CborShapeSerializer extends SerdeContext implements ShapeSerializer {
+    private value;
+    write(schema: Schema, value: unknown): void;
+    /**
+     * Recursive serializer transform that copies and prepares the user input object
+     * for CBOR serialization.
+     */
+    serialize(schema: Schema, source: unknown): any;
+    flush(): Uint8Array;
+}
+/**
+ * @public
+ */
+export declare class CborShapeDeserializer extends SerdeContext implements ShapeDeserializer {
+    read(schema: Schema, bytes: Uint8Array): any;
+    /**
+     * Public because it's called by the protocol implementation to deserialize errors.
+     * @internal
+     */
+    readValue(_schema: Schema, value: any): any;
+}

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

@@ -0,0 +1,28 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { TypeRegistry } from "@smithy/core/schema";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import { CborCodec } from "./CborCodec";
+/**
+ * Client protocol for Smithy RPCv2 CBOR.
+ *
+ * @public
+ */
+export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    private codec;
+    protected serializer: import("./CborCodec").CborShapeSerializer;
+    protected deserializer: import("./CborCodec").CborShapeDeserializer;
+    constructor({ defaultNamespace, errorTypeRegistries, }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    getShapeId(): string;
+    getPayloadCodec(): CborCodec;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected getDefaultContentType(): string;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/cbor/byte-printer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prints bytes as binary string with numbers.
+ * @param bytes - to print.
+ * @deprecated for testing only, do not use in runtime.
+ */
+export declare function printBytes(bytes: Uint8Array): string[];

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * @param _input - JS data object.
+ */
+export declare function encode(_input: any): void;
+/**
+ * @internal
+ */
+export declare function advanceEncodingEpoch(): void;
+/**
+ * @internal
+ */
+export declare function toUint8Array(): Uint8Array;
+export declare function resize(size: number): void;

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

@@ -0,0 +1,65 @@
+export type CborItemType = undefined | boolean | number | bigint | [
+    CborUnstructuredByteStringType,
+    Uint64
+] | string | CborTagType;
+export type CborTagType = {
+    tag: Uint64 | number;
+    value: CborValueType;
+    [tagSymbol]: true;
+};
+export type CborUnstructuredByteStringType = Uint8Array;
+export type CborListType<T = any> = Array<T>;
+export type CborMapType<T = any> = Record<string, T>;
+export type CborCollectionType<T = any> = CborMapType<T> | CborListType<T>;
+export type CborValueType = CborItemType | CborCollectionType | any;
+export type CborArgumentLength = 1 | 2 | 4 | 8;
+export type CborArgumentLengthOffset = 1 | 2 | 3 | 5 | 9;
+export type CborOffset = number;
+export type Uint8 = number;
+export type Uint32 = number;
+export type Uint64 = bigint;
+export type Float32 = number;
+export type Int64 = bigint;
+export type Float16Binary = number;
+export type Float32Binary = number;
+export type CborMajorType = typeof majorUint64 | typeof majorNegativeInt64 | typeof majorUnstructuredByteString | typeof majorUtf8String | typeof majorList | typeof majorMap | typeof majorTag | typeof majorSpecial;
+export declare const majorUint64 = 0;
+export declare const majorNegativeInt64 = 1;
+export declare const majorUnstructuredByteString = 2;
+export declare const majorUtf8String = 3;
+export declare const majorList = 4;
+export declare const majorMap = 5;
+export declare const majorTag = 6;
+export declare const majorSpecial = 7;
+export declare const specialFalse = 20;
+export declare const specialTrue = 21;
+export declare const specialNull = 22;
+export declare const specialUndefined = 23;
+export declare const extendedOneByte = 24;
+export declare const extendedFloat16 = 25;
+export declare const extendedFloat32 = 26;
+export declare const extendedFloat64 = 27;
+export declare const minorIndefinite = 31;
+export declare function alloc(size: number): Uint8Array;
+/**
+ * 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;
+/**
+ * Applies the tag symbol to the object.
+ *
+ * @public
+ */
+export declare function tag(data: {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]?: true;
+}): {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]: true;
+};

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

@@ -0,0 +1,25 @@
+/**
+ * This implementation is synchronous and only implements the parts of CBOR
+ * specification used by Smithy RPCv2 CBOR protocol.
+ *
+ * This cbor serde implementation is derived from AWS SDK for Go's implementation.
+ * @see https://github.com/aws/smithy-go/tree/main/encoding/cbor
+ *
+ * The cbor-x implementation was also instructional:
+ * @see https://github.com/kriszyp/cbor-x
+ */
+export declare const cbor: {
+    deserialize(payload: Uint8Array): any;
+    serialize(input: any): Uint8Array;
+    /**
+     * 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/ts3.4/submodules/cbor/index.d.ts

@@ -0,0 +1,5 @@
+export { cbor } from "./cbor";
+export { tag, tagSymbol } from "./cbor-types";
+export { buildHttpRpcRequest, checkCborResponse, dateToTag, loadSmithyRpcV2CborErrorCode, parseCborBody, parseCborErrorBody, } from "./parseCborBody";
+export { SmithyRpcV2CborProtocol } from "./SmithyRpcV2CborProtocol";
+export { CborCodec, CborShapeDeserializer, CborShapeSerializer } from "./CborCodec";

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

@@ -0,0 +1,31 @@
+import { HttpRequest as __HttpRequest } from "@smithy/core/protocols";
+import { HttpResponse, SerdeContext, HeaderBag as __HeaderBag, SerdeContext as __SerdeContext } from "@smithy/types";
+import { tagSymbol } from "./cbor-types";
+/**
+ * @internal
+ */
+export declare const parseCborBody: (streamBody: any, context: SerdeContext) => any;
+/**
+ * @internal
+ */
+export declare const dateToTag: (date: Date) => {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]: true;
+};
+/**
+ * @internal
+ */
+export declare const parseCborErrorBody: (errorBody: any, context: SerdeContext) => Promise<any>;
+/**
+ * @internal
+ */
+export declare const loadSmithyRpcV2CborErrorCode: (output: HttpResponse, data: any) => string | undefined;
+/**
+ * @internal
+ */
+export declare const checkCborResponse: (response: HttpResponse) => void;
+/**
+ * @internal
+ */
+export declare const buildHttpRpcRequest: (context: __SerdeContext, headers: __HeaderBag, path: string, resolvedHostname: string | undefined, body: any) => Promise<__HttpRequest>;

package/node_modules/@smithy/core/dist-types/ts3.4/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/ts3.4/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/ts3.4/submodules/checksum/crc32/Crc32Js.d.ts

@@ -0,0 +1,18 @@
+import { 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/ts3.4/submodules/checksum/crc32/Crc32Node.d.ts

@@ -0,0 +1,18 @@
+import { 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/ts3.4/submodules/checksum/hash-blob-browser/blobHasher.d.ts

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

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

@@ -0,0 +1,10 @@
+import { Writable, WritableOptions } from "node:stream";
+import { 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/ts3.4/submodules/checksum/hash-stream-node/fileStreamHasher.d.ts

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

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

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

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;
+}