@cdk8s/awscdk-resolver 0.0.301 → 0.0.303

package/node_modules/@smithy/core/dist-types/submodules/protocols/serde/HttpInterceptingShapeSerializer.d.ts

@@ -0,0 +1,20 @@
+import { CodecSettings, Schema as ISchema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
+import { ToStringShapeSerializer } from "./ToStringShapeSerializer";
+/**
+ * This serializer decides whether to dispatch to a string serializer or a codec serializer
+ * depending on HTTP binding traits within the given schema.
+ *
+ * For example, a JavaScript array is serialized differently when being written
+ * to a REST JSON HTTP header (comma-delimited string) and a REST JSON HTTP body (JSON array).
+ *
+ * @alpha
+ */
+export declare class HttpInterceptingShapeSerializer<CodecShapeSerializer extends ShapeSerializer<string | Uint8Array>> implements ShapeSerializer<string | Uint8Array> {
+    private codecSerializer;
+    private stringSerializer;
+    private buffer;
+    constructor(codecSerializer: CodecShapeSerializer, codecSettings: CodecSettings, stringSerializer?: ToStringShapeSerializer);
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    write(schema: ISchema, value: unknown): void;
+    flush(): string | Uint8Array;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/serde/ToStringShapeSerializer.d.ts

@@ -0,0 +1,15 @@
+import { CodecSettings, Schema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
+/**
+ * Serializes a shape to string.
+ *
+ * @alpha
+ */
+export declare class ToStringShapeSerializer implements ShapeSerializer<string> {
+    private settings;
+    private stringBuffer;
+    private serdeContext;
+    constructor(settings: CodecSettings);
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/serde/determineTimestampFormat.d.ts

@@ -0,0 +1,9 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { type TimestampDateTimeSchema, type TimestampEpochSecondsSchema, type TimestampHttpDateSchema, CodecSettings } from "@smithy/types";
+/**
+ * Assuming the schema is a timestamp type, the function resolves the format using
+ * either the timestamp's own traits, or the default timestamp format from the CodecSettings.
+ *
+ * @internal
+ */
+export declare function determineTimestampFormat(ns: NormalizedSchema, settings: CodecSettings): TimestampDateTimeSchema | TimestampHttpDateSchema | TimestampEpochSecondsSchema;

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

@@ -0,0 +1,55 @@
+import type { Schema as ISchema } from "@smithy/types";
+import { ErrorSchema } from "./schemas/ErrorSchema";
+/**
+ * A way to look up schema by their ShapeId values.
+ *
+ * @alpha
+ */
+export declare class TypeRegistry {
+    readonly namespace: string;
+    private schemas;
+    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;
+    /**
+     * Adds the given schema to a type registry with the same namespace.
+     *
+     * @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;
+    /**
+     * 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(): ErrorSchema | undefined;
+    /**
+     * @param predicate - criterion.
+     * @returns a schema in this registry matching the predicate.
+     */
+    find(predicate: (schema: ISchema) => boolean): ISchema | undefined;
+    /**
+     * Unloads the current TypeRegistry.
+     */
+    destroy(): void;
+    private normalizeShapeId;
+    private getNamespace;
+}

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

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

@@ -0,0 +1,12 @@
+export * from "./deref";
+export * from "./middleware/getSchemaSerdePlugin";
+export * from "./schemas/ListSchema";
+export * from "./schemas/MapSchema";
+export * from "./schemas/OperationSchema";
+export * from "./schemas/ErrorSchema";
+export * from "./schemas/NormalizedSchema";
+export * from "./schemas/Schema";
+export * from "./schemas/SimpleSchema";
+export * from "./schemas/StructureSchema";
+export * from "./schemas/sentinels";
+export * from "./TypeRegistry";

package/node_modules/@smithy/core/dist-types/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/submodules/schema/middleware/schema-middleware-types.d.ts

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

package/node_modules/@smithy/core/dist-types/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/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/submodules/schema/schemas/ErrorSchema.d.ts

@@ -0,0 +1,38 @@
+import type { 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.
+ *
+ * @alpha
+ */
+export declare class ErrorSchema extends StructureSchema {
+    name: string;
+    traits: SchemaTraits;
+    memberNames: string[];
+    memberList: SchemaRef[];
+    /**
+     * Constructor for a modeled service exception class that extends Error.
+     */
+    ctor: any;
+    constructor(name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[], 
+    /**
+     * Constructor for a modeled service exception class that extends Error.
+     */
+    ctor: any);
+}
+/**
+ * Factory for ErrorSchema, to reduce codegen output and register the schema.
+ *
+ * @internal
+ *
+ * @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 function error(namespace: string, name: string, traits: SchemaTraits | undefined, memberNames: string[], memberList: SchemaRef[], ctor: any): ErrorSchema;

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

@@ -0,0 +1,20 @@
+import type { 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.
+ *
+ * @alpha
+ */
+export declare class ListSchema extends Schema implements IListSchema {
+    name: string;
+    traits: SchemaTraits;
+    valueSchema: SchemaRef;
+    constructor(name: string, traits: SchemaTraits, valueSchema: SchemaRef);
+}
+/**
+ * Factory for ListSchema.
+ *
+ * @internal
+ */
+export declare function list(namespace: string, name: string, traits: SchemaTraits | undefined, valueSchema: SchemaRef): ListSchema;

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

@@ -0,0 +1,25 @@
+import type { MapSchema as IMapSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A schema with a key schema and value schema.
+ * @alpha
+ */
+export declare class MapSchema extends Schema implements IMapSchema {
+    name: string;
+    traits: SchemaTraits;
+    /**
+     * This is expected to be StringSchema, but may have traits.
+     */
+    keySchema: SchemaRef;
+    valueSchema: SchemaRef;
+    constructor(name: string, traits: SchemaTraits, 
+    /**
+     * This is expected to be StringSchema, but may have traits.
+     */
+    keySchema: SchemaRef, valueSchema: SchemaRef);
+}
+/**
+ * Factory for MapSchema.
+ * @internal
+ */
+export declare function map(namespace: string, name: string, traits: SchemaTraits | undefined, keySchema: SchemaRef, valueSchema: SchemaRef): MapSchema;

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

@@ -0,0 +1,122 @@
+import type { MemberSchema, NormalizedSchema as INormalizedSchema, Schema as ISchema, SchemaRef, SchemaTraits, SchemaTraitsObject } from "@smithy/types";
+/**
+ * Wraps both class instances, numeric sentinel values, and member schema pairs.
+ * Presents a consistent interface for interacting with polymorphic schema representations.
+ *
+ * @alpha
+ */
+export declare class NormalizedSchema implements INormalizedSchema {
+    private readonly ref;
+    private memberName?;
+    private readonly name;
+    private readonly traits;
+    private _isMemberSchema;
+    private schema;
+    private 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.
+     */
+    constructor(ref: SchemaRef, memberName?: string | undefined);
+    /**
+     * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
+     */
+    static of(ref: SchemaRef, memberName?: string): NormalizedSchema;
+    /**
+     * @param indicator - numeric indicator for preset trait combination.
+     * @returns equivalent trait object.
+     */
+    static translateTraits(indicator: SchemaTraits): SchemaTraitsObject;
+    /**
+     * Creates a normalized member schema from the given schema and member name.
+     */
+    private static memberFrom;
+    /**
+     * @returns the underlying non-normalized schema.
+     */
+    getSchema(): Exclude<ISchema, 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.
+     * @throws Error when the schema isn't a member schema.
+     */
+    getMemberName(): string;
+    isMemberSchema(): boolean;
+    isUnitSchema(): boolean;
+    /**
+     * boolean methods on this class help control flow in shape serialization and deserialization.
+     */
+    isListSchema(): boolean;
+    isMapSchema(): boolean;
+    isDocumentSchema(): boolean;
+    isStructSchema(): boolean;
+    isBlobSchema(): boolean;
+    isTimestampSchema(): boolean;
+    isStringSchema(): boolean;
+    isBooleanSchema(): boolean;
+    isNumericSchema(): boolean;
+    isBigIntegerSchema(): boolean;
+    isBigDecimalSchema(): boolean;
+    isStreaming(): 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 member - 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(member: 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.
+     *
+     * @returns a map of member names to member schemas (normalized).
+     */
+    getMemberSchemas(): Record<string, NormalizedSchema>;
+    /**
+     * 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>;
+    /**
+     * @returns a last-resort human-readable name for the schema if it has no other identifiers.
+     */
+    private getSchemaName;
+}

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

@@ -0,0 +1,20 @@
+import type { 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.
+ *
+ * @alpha
+ */
+export declare class OperationSchema extends Schema implements IOperationSchema {
+    name: string;
+    traits: SchemaTraits;
+    input: SchemaRef;
+    output: SchemaRef;
+    constructor(name: string, traits: SchemaTraits, input: SchemaRef, output: SchemaRef);
+}
+/**
+ * Factory for OperationSchema.
+ * @internal
+ */
+export declare function op(namespace: string, name: string, traits: SchemaTraits | undefined, input: SchemaRef, output: SchemaRef): OperationSchema;

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

@@ -0,0 +1,11 @@
+import type { SchemaTraits, TraitsSchema } from "@smithy/types";
+/**
+ * Abstract base for class-based Schema except NormalizedSchema.
+ *
+ * @alpha
+ */
+export declare abstract class Schema implements TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+    protected constructor(name: string, traits: SchemaTraits);
+}

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

@@ -0,0 +1,20 @@
+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.
+ *
+ * @alpha
+ */
+export declare class SimpleSchema extends Schema implements TraitsSchema {
+    name: string;
+    schemaRef: SchemaRef;
+    traits: SchemaTraits;
+    constructor(name: string, schemaRef: SchemaRef, traits: SchemaTraits);
+}
+/**
+ * Factory for simple schema class objects.
+ *
+ * @internal
+ */
+export declare function sim(namespace: string, name: string, schemaRef: SchemaRef, traits: SchemaTraits): SimpleSchema;

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

@@ -0,0 +1,21 @@
+import type { SchemaRef, SchemaTraits, StructureSchema as IStructureSchema } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A structure schema has a known list of members. This is also used for unions.
+ *
+ * @alpha
+ */
+export declare class StructureSchema extends Schema implements IStructureSchema {
+    name: string;
+    traits: SchemaTraits;
+    memberNames: string[];
+    memberList: SchemaRef[];
+    members: Record<string, [SchemaRef, SchemaTraits]>;
+    constructor(name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[]);
+}
+/**
+ * Factory for StructureSchema.
+ *
+ * @internal
+ */
+export declare function struct(namespace: string, name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[]): StructureSchema;

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

@@ -0,0 +1,21 @@
+import { BigDecimalSchema, BigIntegerSchema, BlobSchema, BooleanSchema, DocumentSchema, ListSchemaModifier, MapSchemaModifier, NumericSchema, StreamingBlobSchema, StringSchema, TimestampDateTimeSchema, TimestampDefaultSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema } from "@smithy/types";
+/**
+ * Schema sentinel runtime values.
+ * @alpha
+ */
+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/submodules/serde/copyDocumentWithTransform.d.ts

@@ -0,0 +1,5 @@
+import { SchemaRef } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const copyDocumentWithTransform: (source: any, schemaRef: SchemaRef, transform?: (_: any, schemaRef: SchemaRef) => any) => any;

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

@@ -1,7 +1,8 @@
-export * from "./parse-utils";
+export * from "./copyDocumentWithTransform";
 export * from "./date-utils";
+export * from "./lazy-json";
+export * from "./parse-utils";
 export * from "./quote-header";
+export * from "./split-every";
 export * from "./split-header";
 export * from "./value/NumericValue";
-export * from "./lazy-json";
-export * from "./split-every";

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

@@ -0,0 +1,29 @@
+import { Codec, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+/**
+ * @alpha
+ */
+export declare class CborCodec implements Codec<Uint8Array, Uint8Array> {
+    private serdeContext?;
+    createSerializer(): CborShapeSerializer;
+    createDeserializer(): CborShapeDeserializer;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}
+/**
+ * @alpha
+ */
+export declare class CborShapeSerializer implements ShapeSerializer {
+    private serdeContext?;
+    private value;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    write(schema: Schema, value: unknown): void;
+    flush(): Uint8Array;
+}
+/**
+ * @alpha
+ */
+export declare class CborShapeDeserializer implements ShapeDeserializer {
+    private serdeContext?;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    read(schema: Schema, bytes: Uint8Array): any;
+    private readValue;
+}

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

@@ -0,0 +1,22 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { OperationSchema } from "@smithy/core/schema";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import { CborCodec } from "./CborCodec";
+/**
+ * Client protocol for Smithy RPCv2 CBOR.
+ *
+ * @alpha
+ */
+export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
+    private codec;
+    protected serializer: import("./CborCodec").CborShapeSerializer;
+    protected deserializer: import("./CborCodec").CborShapeDeserializer;
+    constructor({ defaultNamespace }: {
+        defaultNamespace: string;
+    });
+    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>;
+}

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

@@ -1,3 +1,5 @@
 export { cbor } from "./cbor";
+export { tag, tagSymbol } from "./cbor-types";
 export * from "./parseCborBody";
-export { tagSymbol, tag } from "./cbor-types";
+export * from "./SmithyRpcV2CborProtocol";
+export * from "./CborCodec";

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

@@ -0,0 +1,15 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/protocol-http";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, SerdeFunctions } from "@smithy/types";
+import { HttpProtocol } from "./HttpProtocol";
+/**
+ * Base for HTTP-binding protocols. Downstream examples
+ * include AWS REST JSON and AWS REST XML.
+ *
+ * @alpha
+ */
+export declare abstract class HttpBindingProtocol extends HttpProtocol {
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    protected serializeQuery(ns: NormalizedSchema, data: any, query: HttpRequest["query"]): void;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+}

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

@@ -0,0 +1,29 @@
+import { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+/**
+ * Abstract base for HTTP-based client protocols.
+ *
+ * @alpha
+ */
+export declare abstract class HttpProtocol implements ClientProtocol<IHttpRequest, IHttpResponse> {
+    readonly options: {
+        defaultNamespace: string;
+    };
+    protected abstract serializer: ShapeSerializer<string | Uint8Array>;
+    protected abstract deserializer: ShapeDeserializer<string | Uint8Array>;
+    protected serdeContext?: SerdeFunctions;
+    protected constructor(options: {
+        defaultNamespace: string;
+    });
+    abstract getShapeId(): string;
+    abstract getPayloadCodec(): Codec<any, any>;
+    getRequestType(): new (...args: any[]) => IHttpRequest;
+    getResponseType(): new (...args: any[]) => IHttpResponse;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    abstract serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    updateServiceEndpoint(request: IHttpRequest, endpoint: EndpointV2 | Endpoint): IHttpRequest;
+    abstract deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected setHostPrefix<Input extends object>(request: IHttpRequest, operationSchema: OperationSchema, input: Input): void;
+    protected abstract handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected deserializeMetadata(output: IHttpResponse): ResponseMetadata;
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
+}

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

@@ -0,0 +1,11 @@
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, SerdeFunctions } from "@smithy/types";
+import { HttpProtocol } from "./HttpProtocol";
+/**
+ * Abstract base for RPC-over-HTTP protocols.
+ *
+ * @alpha
+ */
+export declare abstract class RpcProtocol extends HttpProtocol {
+    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>;
+}

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

@@ -1,4 +1,11 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
+export * from "./HttpBindingProtocol";
+export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";
+export * from "./serde/FromStringShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeSerializer";
+export * from "./serde/ToStringShapeSerializer";
+export * from "./serde/determineTimestampFormat";

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

@@ -0,0 +1,14 @@
+import { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
+/**
+ * This deserializer reads strings.
+ *
+ * @alpha
+ */
+export declare class FromStringShapeDeserializer implements ShapeDeserializer<string> {
+    private settings;
+    private serdeContext;
+    constructor(settings: CodecSettings);
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    read(_schema: Schema, data: string): any;
+    private base64ToUtf8;
+}