@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

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

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export declare enum RETRY_MODES {
+    STANDARD = "standard",
+    ADAPTIVE = "adaptive"
+}
+/**
+ * The default value for how many HTTP requests an SDK should make for a
+ * single SDK operation invocation before giving up
+ *
+ * @public
+ */
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * The default retry algorithm to use.
+ *
+ * @public
+ */
+export declare const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;

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

@@ -0,0 +1,60 @@
+/**
+ * The base number of milliseconds to use in calculating a suitable cool-down
+ * time when a retryable error is encountered.
+ *
+ * @public
+ */
+export declare const DEFAULT_RETRY_DELAY_BASE = 100;
+/**
+ * The maximum amount of time (in milliseconds) that will be used as a delay
+ * between retry attempts.
+ *
+ * @public
+ */
+export declare const MAXIMUM_RETRY_DELAY: number;
+/**
+ * The retry delay base (in milliseconds) to use when a throttling error is
+ * encountered.
+ *
+ * @public
+ */
+export declare const THROTTLING_RETRY_DELAY_BASE = 500;
+/**
+ * Initial number of retry tokens in Retry Quota
+ *
+ * @public
+ */
+export declare const INITIAL_RETRY_TOKENS = 500;
+/**
+ * The total amount of retry tokens to be decremented from retry token balance.
+ *
+ * @public
+ */
+export declare const RETRY_COST = 5;
+/**
+ * The total amount of retry tokens to be decremented from retry token balance
+ * when a throttling error is encountered.
+ *
+ * @public
+ */
+export declare const TIMEOUT_RETRY_COST = 10;
+/**
+ * The total amount of retry token to be incremented from retry token balance
+ * if an SDK operation invocation succeeds without requiring a retry request.
+ *
+ * @public
+ *
+ */
+export declare const NO_RETRY_INCREMENT = 1;
+/**
+ * Header name for SDK invocation ID
+ *
+ * @public
+ */
+export declare const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+/**
+ * Header name for request retry information.
+ *
+ * @public
+ */
+export declare const REQUEST_HEADER = "amz-sdk-request";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/retries-2026-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export declare abstract class Retry {
+    static v2026: boolean;
+    static delay(): 50 | 100;
+    static throttlingDelay(): 1000 | 500;
+    static cost(): 5 | 14;
+    static throttlingCost(): 5 | 10;
+    static modifiedCostType(): "TRANSIENT" | "THROTTLING";
+}

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

@@ -0,0 +1,19 @@
+/**
+ * @public
+ */
+export interface RateLimiter {
+    /**
+     * If there is sufficient capacity (tokens) available, it immediately returns.
+     * If there is not sufficient capacity, it will either sleep a certain amount
+     * of time until the rate limiter can retrieve a token from its token bucket
+     * or raise an exception indicating there is insufficient capacity.
+     */
+    getSendToken: () => Promise<void>;
+    /**
+     * Updates the client sending rate based on response.
+     * If the response was successful, the capacity and fill rate are increased.
+     * If the response was a throttling response, the capacity and fill rate are
+     * decreased. Transient errors do not affect the rate limiter.
+     */
+    updateClientSendingRate: (response: any) => void;
+}

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

@@ -0,0 +1,71 @@
+import { Schema as ISchema, StaticErrorSchema } from "@smithy/types";
+import { ErrorSchema } from "./schemas/ErrorSchema";
+/**
+ * A way to look up schema by their ShapeId values.
+ *
+ * @public
+ */
+export declare class TypeRegistry {
+    readonly namespace: string;
+    private schemas;
+    private exceptions;
+    static readonly registries: Map<string, TypeRegistry>;
+    private constructor();
+    /**
+     * @param namespace - specifier.
+     * @returns the schema for that namespace, creating it if necessary.
+     */
+    static for(namespace: string): TypeRegistry;
+    /**
+     * Copies entries from another instance without changing the namespace of self.
+     * The composition is additive but non-destructive and will not overwrite existing entries.
+     *
+     * @param other - another TypeRegistry.
+     */
+    copyFrom(other: TypeRegistry): void;
+    /**
+     * Adds the given schema to a type registry with the same namespace, and this registry.
+     *
+     * @param shapeId - to be registered.
+     * @param schema - to be registered.
+     */
+    register(shapeId: string, schema: ISchema): void;
+    /**
+     * @param shapeId - query.
+     * @returns the schema.
+     */
+    getSchema(shapeId: string): ISchema;
+    /**
+     * Associates an error schema with its constructor.
+     */
+    registerError(es: ErrorSchema | StaticErrorSchema, ctor: any): void;
+    /**
+     * @param es - query.
+     * @returns Error constructor that extends the service's base exception.
+     */
+    getErrorCtor(es: ErrorSchema | StaticErrorSchema): any;
+    /**
+     * The smithy-typescript code generator generates a synthetic (i.e. unmodeled) base exception,
+     * because generated SDKs before the introduction of schemas have the notion of a ServiceBaseException, which
+     * is unique per service/model.
+     *
+     * This is generated under a unique prefix that is combined with the service namespace, and this
+     * method is used to retrieve it.
+     *
+     * The base exception synthetic schema is used when an error is returned by a service, but we cannot
+     * determine what existing schema to use to deserialize it.
+     *
+     * @returns the synthetic base exception of the service namespace associated with this registry instance.
+     */
+    getBaseException(): StaticErrorSchema | undefined;
+    /**
+     * @param predicate - criterion.
+     * @returns a schema in this registry matching the predicate.
+     */
+    find(predicate: (schema: ISchema) => boolean): number | "unit" | import("@smithy/types").StaticSimpleSchema | import("@smithy/types").StaticListSchema | import("@smithy/types").StaticMapSchema | import("@smithy/types").StaticStructureSchema | import("@smithy/types").StaticUnionSchema | StaticErrorSchema | import("@smithy/types").StaticOperationSchema | import("@smithy/types").NormalizedSchema | import("@smithy/types").TraitsSchema | import("@smithy/types").MemberSchema | undefined;
+    /**
+     * Unloads the current TypeRegistry.
+     */
+    clear(): void;
+    private normalizeShapeId;
+}

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

@@ -0,0 +1,6 @@
+import { Schema, SchemaRef } from "@smithy/types";
+/**
+ * Dereferences a SchemaRef if needed.
+ * @internal
+ */
+export declare const deref: (schemaRef: SchemaRef) => Schema;

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

@@ -0,0 +1,14 @@
+export { deref } from "./deref";
+export { deserializerMiddlewareOption, getSchemaSerdePlugin, serializerMiddlewareOption, } from "./middleware/getSchemaSerdePlugin";
+export { ListSchema, list } from "./schemas/ListSchema";
+export { MapSchema, map } from "./schemas/MapSchema";
+export { OperationSchema, op } from "./schemas/OperationSchema";
+export { operation } from "./schemas/operation";
+export { ErrorSchema, error } from "./schemas/ErrorSchema";
+export { NormalizedSchema, isStaticSchema, simpleSchemaCacheN, simpleSchemaCacheS } from "./schemas/NormalizedSchema";
+export { Schema } from "./schemas/Schema";
+export { SimpleSchema, sim, simAdapter } from "./schemas/SimpleSchema";
+export { StructureSchema, struct } from "./schemas/StructureSchema";
+export { SCHEMA } from "./schemas/sentinels";
+export { traitsCache, translateTraits } from "./schemas/translateTraits";
+export { TypeRegistry } from "./TypeRegistry";

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

@@ -0,0 +1,14 @@
+import { DeserializeHandlerOptions, MetadataBearer, Pluggable, SerializeHandlerOptions } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const deserializerMiddlewareOption: DeserializeHandlerOptions;
+/**
+ * @internal
+ */
+export declare const serializerMiddlewareOption: SerializeHandlerOptions;
+/**
+ * @internal
+ */
+export declare function getSchemaSerdePlugin<InputType extends object = any, OutputType extends MetadataBearer = any>(config: PreviouslyResolved): Pluggable<InputType, OutputType>;

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

@@ -0,0 +1,11 @@
+import { ClientProtocol, SerdeContext, UrlParser } from "@smithy/types";
+/**
+ * @internal
+ */
+export type PreviouslyResolved = Pick<SerdeContext & {
+    urlParser: UrlParser;
+    protocol: ClientProtocol<any, any>;
+}, Exclude<keyof (SerdeContext & {
+    urlParser: UrlParser;
+    protocol: ClientProtocol<any, any>;
+}), "endpoint">>;

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

@@ -0,0 +1,9 @@
+import { DeserializeHandler, DeserializeHandlerArguments, HandlerExecutionContext } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const schemaDeserializationMiddleware: <O>(config: PreviouslyResolved) => (next: DeserializeHandler<any, any>, context: HandlerExecutionContext) => (args: DeserializeHandlerArguments<any>) => Promise<{
+    response: unknown;
+    output: O;
+}>;

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

@@ -0,0 +1,6 @@
+import { HandlerExecutionContext, SerializeHandler, SerializeHandlerArguments } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const schemaSerializationMiddleware: (config: PreviouslyResolved) => (next: SerializeHandler<any, any>, context: HandlerExecutionContext) => (args: SerializeHandlerArguments<any>) => Promise<import("@smithy/types").SerializeHandlerOutput<any>>;

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

@@ -0,0 +1,37 @@
+import { SchemaRef, SchemaTraits } from "@smithy/types";
+import { StructureSchema } from "./StructureSchema";
+/**
+ * A schema for a structure shape having the error trait. These represent enumerated operation errors.
+ * Because Smithy-TS SDKs use classes for exceptions, whereas plain objects are used for all other data,
+ * and have an existing notion of a XYZServiceBaseException, the ErrorSchema differs from a StructureSchema
+ * by additionally holding the class reference for the corresponding ServiceException class.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class ErrorSchema extends StructureSchema {
+    static readonly symbol: unique symbol;
+    /**
+     * @deprecated - field unused.
+     */
+    ctor: any;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for ErrorSchema, to reduce codegen output and register the schema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ *
+ * @param namespace - shapeId namespace.
+ * @param name - shapeId name.
+ * @param traits - shape level serde traits.
+ * @param memberNames - list of member names.
+ * @param memberList - list of schemaRef corresponding to each
+ * @param _ctor - class reference for the existing Error extending class.
+ */
+export declare const error: (namespace: string, name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[], 
+/**
+ * @deprecated - field unused.
+ */
+_ctor?: any) => ErrorSchema;

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

@@ -0,0 +1,23 @@
+import { ListSchema as IListSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A schema with a single member schema.
+ * The deprecated Set type may be represented as a list.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class ListSchema extends Schema implements IListSchema {
+    static readonly symbol: unique symbol;
+    name: string;
+    traits: SchemaTraits;
+    valueSchema: SchemaRef;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for ListSchema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const list: (namespace: string, name: string, traits: SchemaTraits, valueSchema: SchemaRef) => ListSchema;

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

@@ -0,0 +1,24 @@
+import { MapSchema as IMapSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A schema with a key schema and value schema.
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class MapSchema extends Schema implements IMapSchema {
+    static readonly symbol: unique symbol;
+    name: string;
+    traits: SchemaTraits;
+    /**
+     * This is expected to be StringSchema, but may have traits.
+     */
+    keySchema: SchemaRef;
+    valueSchema: SchemaRef;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for MapSchema.
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const map: (namespace: string, name: string, traits: SchemaTraits, keySchema: SchemaRef, valueSchema: SchemaRef) => MapSchema;

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;