@aws-amplify/graphql-api-construct 1.20.2 → 1.20.3

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js

@@ -0,0 +1,294 @@
+import { deref } from "../deref";
+import { ListSchema } from "./ListSchema";
+import { MapSchema } from "./MapSchema";
+import { SCHEMA } from "./sentinels";
+import { SimpleSchema } from "./SimpleSchema";
+import { StructureSchema } from "./StructureSchema";
+export class NormalizedSchema {
+    constructor(ref, memberName) {
+        this.ref = ref;
+        this.memberName = memberName;
+        const traitStack = [];
+        let _ref = ref;
+        let schema = ref;
+        this._isMemberSchema = false;
+        while (Array.isArray(_ref)) {
+            traitStack.push(_ref[1]);
+            _ref = _ref[0];
+            schema = deref(_ref);
+            this._isMemberSchema = true;
+        }
+        if (traitStack.length > 0) {
+            this.memberTraits = {};
+            for (let i = traitStack.length - 1; i >= 0; --i) {
+                const traitSet = traitStack[i];
+                Object.assign(this.memberTraits, NormalizedSchema.translateTraits(traitSet));
+            }
+        }
+        else {
+            this.memberTraits = 0;
+        }
+        if (schema instanceof NormalizedSchema) {
+            this.name = schema.name;
+            this.traits = schema.traits;
+            this._isMemberSchema = schema._isMemberSchema;
+            this.schema = schema.schema;
+            this.memberTraits = Object.assign({}, schema.getMemberTraits(), this.getMemberTraits());
+            this.normalizedTraits = void 0;
+            this.ref = schema.ref;
+            this.memberName = memberName ?? schema.memberName;
+            return;
+        }
+        this.schema = deref(schema);
+        if (this.schema && typeof this.schema === "object") {
+            this.traits = this.schema?.traits ?? {};
+        }
+        else {
+            this.traits = 0;
+        }
+        this.name =
+            (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
+        if (this._isMemberSchema && !memberName) {
+            throw new Error(`@smithy/core/schema - NormalizedSchema member schema ${this.getName(true)} must initialize with memberName argument.`);
+        }
+    }
+    static of(ref, memberName) {
+        if (ref instanceof NormalizedSchema) {
+            return ref;
+        }
+        return new NormalizedSchema(ref, memberName);
+    }
+    static translateTraits(indicator) {
+        if (typeof indicator === "object") {
+            return indicator;
+        }
+        indicator = indicator | 0;
+        const traits = {};
+        if ((indicator & 1) === 1) {
+            traits.httpLabel = 1;
+        }
+        if (((indicator >> 1) & 1) === 1) {
+            traits.idempotent = 1;
+        }
+        if (((indicator >> 2) & 1) === 1) {
+            traits.idempotencyToken = 1;
+        }
+        if (((indicator >> 3) & 1) === 1) {
+            traits.sensitive = 1;
+        }
+        if (((indicator >> 4) & 1) === 1) {
+            traits.httpPayload = 1;
+        }
+        if (((indicator >> 5) & 1) === 1) {
+            traits.httpResponseCode = 1;
+        }
+        if (((indicator >> 6) & 1) === 1) {
+            traits.httpQueryParams = 1;
+        }
+        return traits;
+    }
+    static memberFrom(memberSchema, memberName) {
+        if (memberSchema instanceof NormalizedSchema) {
+            memberSchema.memberName = memberName;
+            memberSchema._isMemberSchema = true;
+            return memberSchema;
+        }
+        return new NormalizedSchema(memberSchema, memberName);
+    }
+    getSchema() {
+        if (this.schema instanceof NormalizedSchema) {
+            return (this.schema = this.schema.getSchema());
+        }
+        if (this.schema instanceof SimpleSchema) {
+            return deref(this.schema.schemaRef);
+        }
+        return deref(this.schema);
+    }
+    getName(withNamespace = false) {
+        if (!withNamespace) {
+            if (this.name && this.name.includes("#")) {
+                return this.name.split("#")[1];
+            }
+        }
+        return this.name || undefined;
+    }
+    getMemberName() {
+        if (!this.isMemberSchema()) {
+            throw new Error(`@smithy/core/schema - cannot get member name on non-member schema: ${this.getName(true)}`);
+        }
+        return this.memberName;
+    }
+    isMemberSchema() {
+        return this._isMemberSchema;
+    }
+    isUnitSchema() {
+        return this.getSchema() === "unit";
+    }
+    isListSchema() {
+        const inner = this.getSchema();
+        if (typeof inner === "number") {
+            return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
+        }
+        return inner instanceof ListSchema;
+    }
+    isMapSchema() {
+        const inner = this.getSchema();
+        if (typeof inner === "number") {
+            return inner >= SCHEMA.MAP_MODIFIER && inner <= 255;
+        }
+        return inner instanceof MapSchema;
+    }
+    isDocumentSchema() {
+        return this.getSchema() === SCHEMA.DOCUMENT;
+    }
+    isStructSchema() {
+        const inner = this.getSchema();
+        return (inner !== null && typeof inner === "object" && "members" in inner) || inner instanceof StructureSchema;
+    }
+    isBlobSchema() {
+        return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
+    }
+    isTimestampSchema() {
+        const schema = this.getSchema();
+        return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
+    }
+    isStringSchema() {
+        return this.getSchema() === SCHEMA.STRING;
+    }
+    isBooleanSchema() {
+        return this.getSchema() === SCHEMA.BOOLEAN;
+    }
+    isNumericSchema() {
+        return this.getSchema() === SCHEMA.NUMERIC;
+    }
+    isBigIntegerSchema() {
+        return this.getSchema() === SCHEMA.BIG_INTEGER;
+    }
+    isBigDecimalSchema() {
+        return this.getSchema() === SCHEMA.BIG_DECIMAL;
+    }
+    isStreaming() {
+        const streaming = !!this.getMergedTraits().streaming;
+        if (streaming) {
+            return true;
+        }
+        return this.getSchema() === SCHEMA.STREAMING_BLOB;
+    }
+    getMergedTraits() {
+        if (this.normalizedTraits) {
+            return this.normalizedTraits;
+        }
+        this.normalizedTraits = {
+            ...this.getOwnTraits(),
+            ...this.getMemberTraits(),
+        };
+        return this.normalizedTraits;
+    }
+    getMemberTraits() {
+        return NormalizedSchema.translateTraits(this.memberTraits);
+    }
+    getOwnTraits() {
+        return NormalizedSchema.translateTraits(this.traits);
+    }
+    getKeySchema() {
+        if (this.isDocumentSchema()) {
+            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "key");
+        }
+        if (!this.isMapSchema()) {
+            throw new Error(`@smithy/core/schema - cannot get key schema for non-map schema: ${this.getName(true)}`);
+        }
+        const schema = this.getSchema();
+        if (typeof schema === "number") {
+            return NormalizedSchema.memberFrom([63 & schema, 0], "key");
+        }
+        return NormalizedSchema.memberFrom([schema.keySchema, 0], "key");
+    }
+    getValueSchema() {
+        const schema = this.getSchema();
+        if (typeof schema === "number") {
+            if (this.isMapSchema()) {
+                return NormalizedSchema.memberFrom([63 & schema, 0], "value");
+            }
+            else if (this.isListSchema()) {
+                return NormalizedSchema.memberFrom([63 & schema, 0], "member");
+            }
+        }
+        if (schema && typeof schema === "object") {
+            if (this.isStructSchema()) {
+                throw new Error(`cannot call getValueSchema() with StructureSchema ${this.getName(true)}`);
+            }
+            const collection = schema;
+            if ("valueSchema" in collection) {
+                if (this.isMapSchema()) {
+                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "value");
+                }
+                else if (this.isListSchema()) {
+                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "member");
+                }
+            }
+        }
+        if (this.isDocumentSchema()) {
+            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "value");
+        }
+        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
+    }
+    getMemberSchema(member) {
+        if (this.isStructSchema()) {
+            const struct = this.getSchema();
+            if (!(member in struct.members)) {
+                throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`);
+            }
+            return NormalizedSchema.memberFrom(struct.members[member], member);
+        }
+        if (this.isDocumentSchema()) {
+            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
+        }
+        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have members.`);
+    }
+    getMemberSchemas() {
+        const { schema } = this;
+        const struct = schema;
+        if (!struct || typeof struct !== "object") {
+            return {};
+        }
+        if ("members" in struct) {
+            const buffer = {};
+            for (const member of struct.memberNames) {
+                buffer[member] = this.getMemberSchema(member);
+            }
+            return buffer;
+        }
+        return {};
+    }
+    *structIterator() {
+        if (this.isUnitSchema()) {
+            return;
+        }
+        if (!this.isStructSchema()) {
+            throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
+        }
+        const struct = this.getSchema();
+        for (let i = 0; i < struct.memberNames.length; ++i) {
+            yield [struct.memberNames[i], NormalizedSchema.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
+        }
+    }
+    getSchemaName() {
+        const schema = this.getSchema();
+        if (typeof schema === "number") {
+            const _schema = 63 & schema;
+            const container = 192 & schema;
+            const type = Object.entries(SCHEMA).find(([, value]) => {
+                return value === _schema;
+            })?.[0] ?? "Unknown";
+            switch (container) {
+                case SCHEMA.MAP_MODIFIER:
+                    return `${type}Map`;
+                case SCHEMA.LIST_MODIFIER:
+                    return `${type}List`;
+                case 0:
+                    return type;
+            }
+        }
+        return "Unknown";
+    }
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js

@@ -0,0 +1,16 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export class OperationSchema extends Schema {
+    constructor(name, traits, input, output) {
+        super(name, traits);
+        this.name = name;
+        this.traits = traits;
+        this.input = input;
+        this.output = output;
+    }
+}
+export function op(namespace, name, traits = {}, input, output) {
+    const schema = new OperationSchema(namespace + "#" + name, traits, input, output);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js

@@ -0,0 +1,6 @@
+export class Schema {
+    constructor(name, traits) {
+        this.name = name;
+        this.traits = traits;
+    }
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js

@@ -0,0 +1,15 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export class SimpleSchema extends Schema {
+    constructor(name, schemaRef, traits) {
+        super(name, traits);
+        this.name = name;
+        this.schemaRef = schemaRef;
+        this.traits = traits;
+    }
+}
+export function sim(namespace, name, schemaRef, traits) {
+    const schema = new SimpleSchema(namespace + "#" + name, schemaRef, traits);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js

@@ -0,0 +1,22 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export class StructureSchema extends Schema {
+    constructor(name, traits, memberNames, memberList) {
+        super(name, traits);
+        this.name = name;
+        this.traits = traits;
+        this.memberNames = memberNames;
+        this.memberList = memberList;
+        this.members = {};
+        for (let i = 0; i < memberNames.length; ++i) {
+            this.members[memberNames[i]] = Array.isArray(memberList[i])
+                ? memberList[i]
+                : [memberList[i], 0];
+        }
+    }
+}
+export function struct(namespace, name, traits, memberNames, memberList) {
+    const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js

@@ -0,0 +1,16 @@
+export const SCHEMA = {
+    BLOB: 21,
+    STREAMING_BLOB: 42,
+    BOOLEAN: 2,
+    STRING: 0,
+    NUMERIC: 1,
+    BIG_INTEGER: 17,
+    BIG_DECIMAL: 19,
+    DOCUMENT: 15,
+    TIMESTAMP_DEFAULT: 4,
+    TIMESTAMP_DATE_TIME: 5,
+    TIMESTAMP_HTTP_DATE: 6,
+    TIMESTAMP_EPOCH_SECONDS: 7,
+    LIST_MODIFIER: 64,
+    MAP_MODIFIER: 128,
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/serde/copyDocumentWithTransform.js

@@ -0,0 +1,53 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+export const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => {
+    const ns = NormalizedSchema.of(schemaRef);
+    switch (typeof source) {
+        case "undefined":
+        case "boolean":
+        case "number":
+        case "string":
+        case "bigint":
+        case "symbol":
+            return transform(source, ns);
+        case "function":
+        case "object":
+            if (source === null) {
+                return transform(null, ns);
+            }
+            if (Array.isArray(source)) {
+                const newArray = new Array(source.length);
+                let i = 0;
+                for (const item of source) {
+                    newArray[i++] = copyDocumentWithTransform(item, ns.getValueSchema(), transform);
+                }
+                return transform(newArray, ns);
+            }
+            if ("byteLength" in source) {
+                const newBytes = new Uint8Array(source.byteLength);
+                newBytes.set(source, 0);
+                return transform(newBytes, ns);
+            }
+            if (source instanceof Date) {
+                return transform(source, ns);
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                for (const key of Object.keys(source)) {
+                    newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
+                }
+            }
+            else if (ns.isStructSchema()) {
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    newObject[key] = copyDocumentWithTransform(source[key], memberSchema, transform);
+                }
+            }
+            else if (ns.isDocumentSchema()) {
+                for (const key of Object.keys(source)) {
+                    newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
+                }
+            }
+            return transform(newObject, ns);
+        default:
+            return transform(source, ns);
+    }
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-es/submodules/serde/index.js

@@ -1 +1,8 @@
+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";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/httpAuthSchemeMiddleware.d.ts

@@ -1,8 +1,9 @@
-import { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
+import { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
 /**
  * @internal
  */
 export interface PreviouslyResolved<TParameters extends HttpAuthSchemeParameters> {
+    authSchemePreference?: Provider<string[]>;
     httpAuthSchemes: HttpAuthScheme[];
     httpAuthSchemeProvider: HttpAuthSchemeProvider<TParameters>;
 }

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/resolveAuthOptions.d.ts

@@ -0,0 +1,10 @@
+import { HttpAuthOption } from "@smithy/types";
+/**
+ * Resolves list of auth options based on the supported ones, vs the preference list.
+ *
+ * @param candidateAuthOptions list of supported auth options selected by the standard
+ *   resolution process (model-based, endpoints 2.0, etc.)
+ * @param authSchemePreference list of auth schemes preferred by user.
+ * @returns
+ */
+export declare const resolveAuthOptions: (candidateAuthOptions: HttpAuthOption[], authSchemePreference: string[]) => HttpAuthOption[];

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/cbor/SmithyRpcV2CborProtocol.d.ts

@@ -0,0 +1,22 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { OperationSchema } from "@smithy/core/schema";
+import type { 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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-types.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export type CborItemType = undefined | boolean | number | bigint | [CborUnstructuredByteStringType, Uint64] | string | CborTagType;
 export type CborTagType = {
     tag: Uint64 | number;
@@ -39,7 +37,7 @@ 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 | Buffer;
+export declare function alloc(size: number): Uint8Array<ArrayBuffer> | Buffer<ArrayBuffer>;
 /**
  * @public
  *

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/cbor/cbor.d.ts

@@ -10,7 +10,7 @@
  */
 export declare const cbor: {
     deserialize(payload: Uint8Array): any;
-    serialize(input: any): Uint8Array;
+    serialize(input: any): Uint8Array<ArrayBufferLike>;
     /**
      * @public
      * @param size - byte length to allocate.

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

@@ -1,6 +1,6 @@
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { HeaderBag as __HeaderBag, HttpResponse, SerdeContext as __SerdeContext, SerdeContext } from "@smithy/types";
-import { tag, tagSymbol } from "./cbor-types";
+import { tagSymbol } from "./cbor-types";
 /**
  * @internal
  */

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/protocols/HttpProtocol.d.ts

@@ -0,0 +1,33 @@
+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;
+    /**
+     * @deprecated use signature without headerBindings.
+     */
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[]>;
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/submodules/protocols/collect-stream-body.d.ts

@@ -5,6 +5,6 @@ import { Uint8ArrayBlobAdapter } from "@smithy/util-stream";
  *
  * Collect low-level response body stream to Uint8Array.
  */
-export declare const collectBody: (streamBody: any, context: {
+export declare const collectBody: (streamBody: any | undefined, context: {
     streamCollector: SerdeContext["streamCollector"];
 }) => Promise<Uint8ArrayBlobAdapter>;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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/@aws-sdk/client-bedrock-runtime/node_modules/@smithy/core/dist-types/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;
+}