@cdklabs/cdk-ssm-documents 0.0.68 → 0.0.69

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/NormalizedSchema.d.ts

@@ -0,0 +1,146 @@
+import { $MemberSchema, $Schema, $SchemaRef, NormalizedSchema as INormalizedSchema, SchemaRef, SchemaTraitsObject, StaticSchema } from "@smithy/types";
+/**
+ * Cache for numeric schemaRef. Having separate cache objects for number/string improves
+ * lookup performance.
+ * @internal
+ */
+export declare const simpleSchemaCacheN: Array<NormalizedSchema | undefined>;
+/**
+ * Cache for string schemaRef.
+ * @internal
+ */
+export declare const simpleSchemaCacheS: Record<string, NormalizedSchema>;
+/**
+ * Wraps both class instances, numeric sentinel values, and member schema pairs.
+ * Presents a consistent interface for interacting with polymorphic schema representations.
+ *
+ * @public
+ */
+export declare class NormalizedSchema implements INormalizedSchema {
+    readonly ref: $SchemaRef;
+    private readonly memberName?;
+    static readonly symbol: unique symbol;
+    protected readonly symbol: symbol;
+    private readonly name;
+    private readonly schema;
+    private readonly _isMemberSchema;
+    private readonly traits;
+    private readonly memberTraits;
+    private normalizedTraits?;
+    /**
+     * @param ref - a polymorphic SchemaRef to be dereferenced/normalized.
+     * @param memberName - optional memberName if this NormalizedSchema should be considered a member schema.
+     */
+    private constructor();
+    static [Symbol.hasInstance](lhs: unknown): lhs is NormalizedSchema;
+    /**
+     * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
+     */
+    static of(ref: SchemaRef | $SchemaRef): NormalizedSchema;
+    /**
+     * @returns the underlying non-normalized schema.
+     */
+    getSchema(): Exclude<$Schema, $MemberSchema | INormalizedSchema>;
+    /**
+     * @param withNamespace - qualifies the name.
+     * @returns e.g. `MyShape` or `com.namespace#MyShape`.
+     */
+    getName(withNamespace?: boolean): string | undefined;
+    /**
+     * @returns the member name if the schema is a member schema.
+     */
+    getMemberName(): string;
+    isMemberSchema(): boolean;
+    /**
+     * boolean methods on this class help control flow in shape serialization and deserialization.
+     */
+    isListSchema(): boolean;
+    isMapSchema(): boolean;
+    /**
+     * To simplify serialization logic, static union schemas are considered a specialization
+     * of structs in the TypeScript typings and JS runtime, as well as static error schemas
+     * which have a different identifier.
+     */
+    isStructSchema(): boolean;
+    isUnionSchema(): boolean;
+    isBlobSchema(): boolean;
+    isTimestampSchema(): boolean;
+    isUnitSchema(): boolean;
+    isDocumentSchema(): boolean;
+    isStringSchema(): boolean;
+    isBooleanSchema(): boolean;
+    isNumericSchema(): boolean;
+    isBigIntegerSchema(): boolean;
+    isBigDecimalSchema(): boolean;
+    isStreaming(): boolean;
+    /**
+     * @returns whether the schema has the idempotencyToken trait.
+     */
+    isIdempotencyToken(): boolean;
+    /**
+     * @returns own traits merged with member traits, where member traits of the same trait key take priority.
+     * This method is cached.
+     */
+    getMergedTraits(): SchemaTraitsObject;
+    /**
+     * @returns only the member traits. If the schema is not a member, this returns empty.
+     */
+    getMemberTraits(): SchemaTraitsObject;
+    /**
+     * @returns only the traits inherent to the shape or member target shape if this schema is a member.
+     * If there are any member traits they are excluded.
+     */
+    getOwnTraits(): SchemaTraitsObject;
+    /**
+     * @returns the map's key's schema. Returns a dummy Document schema if this schema is a Document.
+     *
+     * @throws Error if the schema is not a Map or Document.
+     */
+    getKeySchema(): NormalizedSchema;
+    /**
+     * @returns the schema of the map's value or list's member.
+     * Returns a dummy Document schema if this schema is a Document.
+     *
+     * @throws Error if the schema is not a Map, List, nor Document.
+     */
+    getValueSchema(): NormalizedSchema;
+    /**
+     * @returns the NormalizedSchema for the given member name. The returned instance will return true for `isMemberSchema()`
+     * and will have the member name given.
+     * @param memberName - which member to retrieve and wrap.
+     *
+     * @throws Error if member does not exist or the schema is neither a document nor structure.
+     * Note that errors are assumed to be structures and unions are considered structures for these purposes.
+     */
+    getMemberSchema(memberName: string): NormalizedSchema;
+    /**
+     * This can be used for checking the members as a hashmap.
+     * Prefer the structIterator method for iteration.
+     *
+     * This does NOT return list and map members, it is only for structures.
+     *
+     * @deprecated use (checked) structIterator instead.
+     *
+     * @returns a map of member names to member schemas (normalized).
+     */
+    getMemberSchemas(): Record<string, NormalizedSchema>;
+    /**
+     * @returns member name of event stream or empty string indicating none exists or this
+     * isn't a structure schema.
+     */
+    getEventStreamMember(): string;
+    /**
+     * Allows iteration over members of a structure schema.
+     * Each yield is a pair of the member name and member schema.
+     *
+     * This avoids the overhead of calling Object.entries(ns.getMemberSchemas()).
+     */
+    structIterator(): Generator<[
+        string,
+        NormalizedSchema
+    ], undefined, undefined>;
+}
+/**
+ * @internal
+ */
+export declare const isStaticSchema: (sc: SchemaRef) => sc is StaticSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/OperationSchema.d.ts

@@ -0,0 +1,23 @@
+import { OperationSchema as IOperationSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * This is used as a reference container for the input/output pair of schema, and for trait
+ * detection on the operation that may affect client protocol logic.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class OperationSchema extends Schema implements IOperationSchema {
+    static readonly symbol: unique symbol;
+    name: string;
+    traits: SchemaTraits;
+    input: SchemaRef;
+    output: SchemaRef;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for OperationSchema.
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const op: (namespace: string, name: string, traits: SchemaTraits, input: SchemaRef, output: SchemaRef) => OperationSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/Schema.d.ts

@@ -0,0 +1,16 @@
+import { SchemaTraits, TraitsSchema } from "@smithy/types";
+/**
+ * Abstract base for class-based Schema except NormalizedSchema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare abstract class Schema implements TraitsSchema {
+    name: string;
+    namespace: string;
+    traits: SchemaTraits;
+    protected abstract readonly symbol: symbol;
+    static assign<T extends Schema>(instance: T, values: Pick<T, Exclude<keyof T, "getName" | "symbol">>): T;
+    static [Symbol.hasInstance](lhs: unknown): boolean;
+    getName(): string;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/SimpleSchema.d.ts

@@ -0,0 +1,28 @@
+import { SchemaRef, SchemaTraits, TraitsSchema } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * Although numeric values exist for most simple schema, this class is used for cases where traits are
+ * attached to those schema, since a single number cannot easily represent both a schema and its traits.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class SimpleSchema extends Schema implements TraitsSchema {
+    static readonly symbol: unique symbol;
+    name: string;
+    schemaRef: SchemaRef;
+    traits: SchemaTraits;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for simple schema class objects.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const sim: (namespace: string, name: string, schemaRef: SchemaRef, traits: SchemaTraits) => SimpleSchema;
+/**
+ * @internal
+ * @deprecated
+ */
+export declare const simAdapter: (namespace: string, name: string, traits: SchemaTraits, schemaRef: SchemaRef) => SimpleSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/StructureSchema.d.ts

@@ -0,0 +1,23 @@
+import { StructureSchema as IStructureSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A structure schema has a known list of members. This is also used for unions.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class StructureSchema extends Schema implements IStructureSchema {
+    static symbol: symbol;
+    name: string;
+    traits: SchemaTraits;
+    memberNames: string[];
+    memberList: SchemaRef[];
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for StructureSchema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const struct: (namespace: string, name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[]) => StructureSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/operation.d.ts

@@ -0,0 +1,7 @@
+import { OperationSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+/**
+ * Converts the static schema array into an object-form to adapt
+ * to the signature of ClientProtocol classes.
+ * @internal
+ */
+export declare const operation: (namespace: string, name: string, traits: SchemaTraits, input: SchemaRef, output: SchemaRef) => OperationSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/sentinels.d.ts

@@ -0,0 +1,23 @@
+import { BigDecimalSchema, BigIntegerSchema, BlobSchema, BooleanSchema, DocumentSchema, ListSchemaModifier, MapSchemaModifier, NumericSchema, StreamingBlobSchema, StringSchema, TimestampDateTimeSchema, TimestampDefaultSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema } from "@smithy/types";
+/**
+ * Schema sentinel runtime values.
+ * @internal
+ *
+ * @deprecated use inline numbers with type annotation to save space.
+ */
+export declare const SCHEMA: {
+    BLOB: BlobSchema;
+    STREAMING_BLOB: StreamingBlobSchema;
+    BOOLEAN: BooleanSchema;
+    STRING: StringSchema;
+    NUMERIC: NumericSchema;
+    BIG_INTEGER: BigIntegerSchema;
+    BIG_DECIMAL: BigDecimalSchema;
+    DOCUMENT: DocumentSchema;
+    TIMESTAMP_DEFAULT: TimestampDefaultSchema;
+    TIMESTAMP_DATE_TIME: TimestampDateTimeSchema;
+    TIMESTAMP_HTTP_DATE: TimestampHttpDateSchema;
+    TIMESTAMP_EPOCH_SECONDS: TimestampEpochSecondsSchema;
+    LIST_MODIFIER: ListSchemaModifier;
+    MAP_MODIFIER: MapSchemaModifier;
+};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/translateTraits.d.ts

@@ -0,0 +1,13 @@
+import { SchemaTraits, SchemaTraitsObject } from "@smithy/types";
+/**
+ * Module-level cache for translateTraits() numeric bitmask inputs.
+ *
+ * @internal
+ */
+export declare const traitsCache: SchemaTraitsObject[];
+/**
+ * @internal
+ * @param indicator - numeric indicator for preset trait combination.
+ * @returns equivalent trait object.
+ */
+export declare function translateTraits(indicator: SchemaTraits): SchemaTraitsObject;

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

@@ -0,0 +1,6 @@
+/**
+ * This deliberately avoids differentiating to Buffer.concat in Node.js in favor of being isomorphic.
+ * This implementation pattern is highly recognizable/optimizable by JS engines.
+ * @internal
+ */
+export declare function concatBytes(arrays: Uint8Array[], length?: number): Uint8Array;

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

@@ -0,0 +1,6 @@
+import { SchemaRef } from "@smithy/types";
+/**
+ * @internal
+ * @deprecated the former functionality has been internalized to the CborCodec.
+ */
+export declare const copyDocumentWithTransform: (source: any, schemaRef: SchemaRef, transform?: (_: any, schemaRef: SchemaRef) => any) => any;

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

@@ -0,0 +1,61 @@
+/**
+ * Builds a proper UTC HttpDate timestamp from a Date object
+ * since not all environments will have this as the expected
+ * format.
+ * - Prior to ECMAScript 2018, the format of the return value
+ * - varied according to the platform. The most common return
+ * - value was an RFC-1123 formatted date stamp, which is a
+ * - slightly updated version of RFC-822 date stamps.
+ *
+ * @internal
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString}
+ */
+export declare function dateToUtcString(date: Date): string;
+/**
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 3339 date.
+ * Input strings must conform to RFC3339 section 5.6, and cannot have a UTC
+ * offset. Fractional precision is supported.
+ *
+ * @internal
+ * @see {@link https://xml2rfc.tools.ietf.org/public/rfc/html/rfc3339.html#anchor14}
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc3339DateTime: (value: unknown) => Date | undefined;
+/**
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 3339 date.
+ * Input strings must conform to RFC3339 section 5.6, and can have a UTC
+ * offset. Fractional precision is supported.
+ *
+ * @internal
+ * @see {@link https://xml2rfc.tools.ietf.org/public/rfc/html/rfc3339.html#anchor14}
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc3339DateTimeWithOffset: (value: unknown) => Date | undefined;
+/**
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 7231 IMF-fixdate or obs-date.
+ * Input strings must conform to RFC7231 section 7.1.1.1. Fractional seconds are supported.
+ *
+ * @internal
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7231.html#section-7.1.1.1}
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc7231DateTime: (value: unknown) => Date | undefined;
+/**
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a number or a parseable string.
+ * Input strings must be an integer or floating point number. Fractional seconds are supported.
+ *
+ * @internal
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseEpochTimestamp: (value: unknown) => Date | undefined;

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

@@ -0,0 +1,13 @@
+import { Checksum, SourceData } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class Hash implements Checksum {
+    private readonly algorithmIdentifier;
+    private readonly secret?;
+    private hash;
+    constructor(algorithmIdentifier: string, secret?: SourceData);
+    update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

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

@@ -0,0 +1,41 @@
+import { fromBase64 } from "./util-base64/fromBase64.browser";
+import { toBase64 } from "./util-base64/toBase64.browser";
+import { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+import { toUtf8 } from "./util-utf8/toUtf8.browser";
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { LazyJsonString, AutomaticJsonStringConversion } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv, NumericType } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { toBase64, fromBase64 };
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength.browser";
+export { toUint8Array } from "./util-utf8/toUint8Array.browser";
+export { toUtf8, fromUtf8 };
+export { concatBytes } from "./concatBytes";
+export { StringEncoding } from "./util-buffer-from/buffer-from";
+export declare const fromArrayBuffer: symbol;
+export declare const fromString: symbol;
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, V1OrV2Endpoint } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export declare const Hash: symbol;
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
+export { ChecksumStream, ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream.browser";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream.browser";
+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";
+export declare const v4: () => string;
+export declare const generateIdempotencyToken: () => string;

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

@@ -0,0 +1,39 @@
+import { fromBase64 } from "./util-base64/fromBase64";
+import { toBase64 } from "./util-base64/toBase64";
+import { fromUtf8 } from "./util-utf8/fromUtf8";
+import { toUtf8 } from "./util-utf8/toUtf8";
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { LazyJsonString, AutomaticJsonStringConversion } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv, NumericType } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { toBase64, fromBase64 };
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength";
+export { toUint8Array } from "./util-utf8/toUint8Array";
+export { toUtf8, fromUtf8 };
+export { concatBytes } from "./concatBytes";
+export { fromArrayBuffer, fromString, StringEncoding } from "./util-buffer-from/buffer-from";
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, V1OrV2Endpoint } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export { Hash } from "./hash-node/hash-node";
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
+export { ChecksumStream, ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream";
+export { headStream } from "./util-stream/headStream";
+export { sdkStreamMixin } from "./util-stream/sdk-stream-mixin";
+export { splitStream } from "./util-stream/splitStream";
+export { isReadableStream, isBlob } from "./util-stream/stream-type-check";
+export { streamCollector } from "./util-stream/stream-collector";
+export declare const v4: () => string;
+export declare const generateIdempotencyToken: () => string;

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

@@ -0,0 +1,39 @@
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { LazyJsonString, AutomaticJsonStringConversion } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv, NumericType } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { fromBase64 } from "./util-base64/fromBase64.browser";
+export { toBase64 } from "./util-base64/toBase64.browser";
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength.browser";
+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 { StringEncoding } from "./util-buffer-from/buffer-from";
+export declare const fromArrayBuffer: symbol;
+export declare const fromString: symbol;
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, V1OrV2Endpoint } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export declare const Hash: symbol;
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
+export { ChecksumStream, ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream.browser";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream.browser";
+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";
+export declare const v4: () => string;
+export declare const generateIdempotencyToken: () => string;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/serde/is-array-buffer/is-array-buffer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const isArrayBuffer: (arg: any) => arg is ArrayBuffer;

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

@@ -0,0 +1,43 @@
+/**
+ * A model field with this type means that you may provide a JavaScript
+ * object in lieu of a JSON string, and it will be serialized to JSON
+ * automatically before being sent in a request.
+ * For responses, you will receive a "LazyJsonString", which is a boxed String object
+ * with additional mixin methods.
+ * To get the string value, call `.toString()`, or to get the JSON object value,
+ * call `.deserializeJSON()` or parse it yourself.
+ *
+ * @public
+ */
+export type AutomaticJsonStringConversion = Parameters<typeof JSON.stringify>[0] | LazyJsonString;
+/**
+ * @internal
+ */
+export interface LazyJsonString extends String {
+    /**
+     * @returns the JSON parsing of the string value.
+     */
+    deserializeJSON(): any;
+    /**
+     * @returns the original string value rather than a JSON.stringified value.
+     */
+    toJSON(): string;
+}
+/**
+ * Extension of the native String class in the previous implementation
+ * has negative global performance impact on method dispatch for strings,
+ * and is generally discouraged.
+ * This current implementation may look strange, but is necessary to preserve the interface and
+ * behavior of extending the String class.
+ *
+ * @internal
+ */
+export declare const LazyJsonString: {
+    new (s: string): LazyJsonString;
+    (s: string): LazyJsonString;
+    from(s: any): LazyJsonString;
+    /**
+     * @deprecated use #from.
+     */
+    fromObject(s: any): LazyJsonString;
+};

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

@@ -0,0 +1,6 @@
+import { DeserializeMiddleware, ResponseDeserializer, SerdeContext, SerdeFunctions } from "@smithy/types";
+/**
+ * @internal
+ * @deprecated will be replaced by schemaSerdePlugin from core/schema.
+ */
+export declare const deserializerMiddleware: <Input extends object = any, Output extends object = any, CommandSerdeContext extends SerdeContext = any>(options: SerdeFunctions, deserializer: ResponseDeserializer<any, any, CommandSerdeContext>) => DeserializeMiddleware<Input, Output>;

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

@@ -0,0 +1,24 @@
+import { DeserializeHandlerOptions, Endpoint, MetadataBearer, Pluggable, Provider, RequestSerializer, ResponseDeserializer, SerdeContext, SerdeFunctions, SerializeHandlerOptions, UrlParser } from "@smithy/types";
+/**
+ * @deprecated will be replaced by schemaSerdePlugin from core/schema.
+ */
+export declare const deserializerMiddlewareOption: DeserializeHandlerOptions;
+/**
+ * @deprecated will be replaced by schemaSerdePlugin from core/schema.
+ */
+export declare const serializerMiddlewareOption: SerializeHandlerOptions;
+/**
+ * Modifies the EndpointBearer to make it compatible with Endpoints 2.0 change.
+ *
+ * @internal
+ * @deprecated
+ */
+export type V1OrV2Endpoint = {
+    urlParser?: UrlParser;
+    endpoint?: Provider<Endpoint>;
+};
+/**
+ * @internal
+ * @deprecated will be replaced by schemaSerdePlugin from core/schema.
+ */
+export declare function getSerdePlugin<InputType extends object = any, CommandSerdeContext extends SerdeContext = any, OutputType extends MetadataBearer = any>(config: SerdeFunctions, serializer: RequestSerializer<any, CommandSerdeContext>, deserializer: ResponseDeserializer<OutputType, any, CommandSerdeContext>): Pluggable<InputType, OutputType>;

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

@@ -0,0 +1,6 @@
+import { RequestSerializer, SerdeContext, SerdeFunctions, SerializeMiddleware } from "@smithy/types";
+/**
+ * @internal
+ * @deprecated will be replaced by schemaSerdePlugin from core/schema.
+ */
+export declare const serializerMiddleware: <Input extends object = any, Output extends object = any, CommandSerdeContext extends SerdeContext = any>(options: SerdeFunctions, serializer: RequestSerializer<any, CommandSerdeContext>) => SerializeMiddleware<Input, Output>;