lambda-live-debugger 1.8.6 → 1.9.0

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -0,0 +1,200 @@
+import { SCHEMA } from "@smithy/core/schema";
+import { fromUtf8 } from "@smithy/util-utf8";
+export class EventStreamSerde {
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {
+        this.marshaller = marshaller;
+        this.serializer = serializer;
+        this.deserializer = deserializer;
+        this.serdeContext = serdeContext;
+        this.defaultContentType = defaultContentType;
+    }
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = requestSchema.getEventStreamMember();
+        const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+        const memberSchemas = unionSchema.getMemberSchemas();
+        const serializer = this.serializer;
+        const defaultContentType = this.defaultContentType;
+        const initialRequestMarker = Symbol("initialRequestMarker");
+        const eventStreamIterable = {
+            async *[Symbol.asyncIterator]() {
+                if (initialRequest) {
+                    const headers = {
+                        ":event-type": { type: "string", value: "initial-request" },
+                        ":message-type": { type: "string", value: "event" },
+                        ":content-type": { type: "string", value: defaultContentType },
+                    };
+                    serializer.write(requestSchema, initialRequest);
+                    const body = serializer.flush();
+                    yield {
+                        [initialRequestMarker]: true,
+                        headers,
+                        body,
+                    };
+                }
+                for await (const page of eventStream) {
+                    yield page;
+                }
+            },
+        };
+        return marshaller.serialize(eventStreamIterable, (event) => {
+            if (event[initialRequestMarker]) {
+                return {
+                    headers: event.headers,
+                    body: event.body,
+                };
+            }
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+            const headers = {
+                ":event-type": { type: "string", value: eventType },
+                ":message-type": { type: "string", value: "event" },
+                ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+                ...additionalHeaders,
+            };
+            return {
+                headers,
+                body,
+            };
+        });
+    }
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = responseSchema.getEventStreamMember();
+        const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+        const memberSchemas = unionSchema.getMemberSchemas();
+        const initialResponseMarker = Symbol("initialResponseMarker");
+        const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            if (unionMember === "initial-response") {
+                const dataObject = await this.deserializer.read(responseSchema, event[unionMember].body);
+                delete dataObject[eventStreamMember];
+                return {
+                    [initialResponseMarker]: true,
+                    ...dataObject,
+                };
+            }
+            else if (unionMember in memberSchemas) {
+                const eventStreamSchema = memberSchemas[unionMember];
+                return {
+                    [unionMember]: await this.deserializer.read(eventStreamSchema, event[unionMember].body),
+                };
+            }
+            else {
+                return {
+                    $unknown: event,
+                };
+            }
+        });
+        const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+        const firstEvent = await asyncIterator.next();
+        if (firstEvent.done) {
+            return asyncIterable;
+        }
+        if (firstEvent.value?.[initialResponseMarker]) {
+            if (!responseSchema) {
+                throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+            }
+            for (const [key, value] of Object.entries(firstEvent.value)) {
+                initialResponseContainer[key] = value;
+            }
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                if (!firstEvent?.value?.[initialResponseMarker]) {
+                    yield firstEvent.value;
+                }
+                while (true) {
+                    const { done, value } = await asyncIterator.next();
+                    if (done) {
+                        break;
+                    }
+                    yield value;
+                }
+            },
+        };
+    }
+    writeEventBody(unionMember, unionSchema, event) {
+        const serializer = this.serializer;
+        let eventType = unionMember;
+        let explicitPayloadMember = null;
+        let explicitPayloadContentType;
+        const isKnownSchema = unionSchema.hasMemberSchema(unionMember);
+        const additionalHeaders = {};
+        if (!isKnownSchema) {
+            const [type, value] = event[unionMember];
+            eventType = type;
+            serializer.write(SCHEMA.DOCUMENT, value);
+        }
+        else {
+            const eventSchema = unionSchema.getMemberSchema(unionMember);
+            if (eventSchema.isStructSchema()) {
+                for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+                    const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+                    if (eventPayload) {
+                        explicitPayloadMember = memberName;
+                        break;
+                    }
+                    else if (eventHeader) {
+                        const value = event[unionMember][memberName];
+                        let type = "binary";
+                        if (memberSchema.isNumericSchema()) {
+                            if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                                type = "integer";
+                            }
+                            else {
+                                type = "long";
+                            }
+                        }
+                        else if (memberSchema.isTimestampSchema()) {
+                            type = "timestamp";
+                        }
+                        else if (memberSchema.isStringSchema()) {
+                            type = "string";
+                        }
+                        else if (memberSchema.isBooleanSchema()) {
+                            type = "boolean";
+                        }
+                        if (value != null) {
+                            additionalHeaders[memberName] = {
+                                type,
+                                value,
+                            };
+                            delete event[unionMember][memberName];
+                        }
+                    }
+                }
+                if (explicitPayloadMember !== null) {
+                    const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+                    if (payloadSchema.isBlobSchema()) {
+                        explicitPayloadContentType = "application/octet-stream";
+                    }
+                    else if (payloadSchema.isStringSchema()) {
+                        explicitPayloadContentType = "text/plain";
+                    }
+                    serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+                }
+                else {
+                    serializer.write(eventSchema, event[unionMember]);
+                }
+            }
+            else {
+                throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+            }
+        }
+        const messageSerialization = serializer.flush();
+        const body = typeof messageSerialization === "string"
+            ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization)
+            : messageSerialization;
+        return {
+            body,
+            eventType,
+            explicitPayloadContentType,
+            additionalHeaders,
+        };
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js

@@ -0,0 +1 @@
+export * from "./EventStreamSerde";

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js

@@ -56,7 +56,12 @@ export class HttpBindingProtocol extends HttpProtocol {
                 if (isStreaming) {
                     const isEventStream = memberNs.isStructSchema();
                     if (isEventStream) {
-                        throw new Error("serialization of event streams is not yet implemented");
+                        if (input[memberName]) {
+                            payload = await this.serializeEventStream({
+                                eventStream: input[memberName],
+                                requestSchema: ns,
+                            });
+                        }
                     }
                     else {
                         payload = inputMemberValue;
@@ -171,11 +176,8 @@ export class HttpBindingProtocol extends HttpProtocol {
                 }
             }
         }
-        const output = {
-            $metadata: this.deserializeMetadata(response),
-            ...dataObject,
-        };
-        return output;
+        dataObject.$metadata = this.deserializeMetadata(response);
+        return dataObject;
     }
     async deserializeHttpMessage(schema, context, response, arg4, arg5) {
         let dataObject;
@@ -195,26 +197,9 @@ export class HttpBindingProtocol extends HttpProtocol {
                 if (isStreaming) {
                     const isEventStream = memberSchema.isStructSchema();
                     if (isEventStream) {
-                        const context = this.serdeContext;
-                        if (!context.eventStreamMarshaller) {
-                            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
-                        }
-                        const memberSchemas = memberSchema.getMemberSchemas();
-                        dataObject[memberName] = context.eventStreamMarshaller.deserialize(response.body, async (event) => {
-                            const unionMember = Object.keys(event).find((key) => {
-                                return key !== "__type";
-                            }) ?? "";
-                            if (unionMember in memberSchemas) {
-                                const eventStreamSchema = memberSchemas[unionMember];
-                                return {
-                                    [unionMember]: await deserializer.read(eventStreamSchema, event[unionMember].body),
-                                };
-                            }
-                            else {
-                                return {
-                                    $unknown: event,
-                                };
-                            }
+                        dataObject[memberName] = await this.deserializeEventStream({
+                            response,
+                            responseSchema: ns,
                         });
                     }
                     else {

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -72,6 +72,35 @@ export class HttpProtocol {
             cfId: output.headers["x-amz-cf-id"],
         };
     }
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
+        const eventStreamSerde = await this.loadEventStreamCapability();
+        return eventStreamSerde.serializeEventStream({
+            eventStream,
+            requestSchema,
+            initialRequest,
+        });
+    }
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
+        const eventStreamSerde = await this.loadEventStreamCapability();
+        return eventStreamSerde.deserializeEventStream({
+            response,
+            responseSchema,
+            initialResponseContainer,
+        });
+    }
+    async loadEventStreamCapability() {
+        const { EventStreamSerde } = await import("@smithy/core/event-streams");
+        return new EventStreamSerde({
+            marshaller: this.getEventStreamMarshaller(),
+            serializer: this.serializer,
+            deserializer: this.deserializer,
+            serdeContext: this.serdeContext,
+            defaultContentType: this.getDefaultContentType(),
+        });
+    }
+    getDefaultContentType() {
+        throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
+    }
     async deserializeHttpMessage(schema, context, response, arg4, arg5) {
         void schema;
         void context;
@@ -80,4 +109,11 @@ export class HttpProtocol {
         void arg5;
         return [];
     }
+    getEventStreamMarshaller() {
+        const context = this.serdeContext;
+        if (!context.eventStreamMarshaller) {
+            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
+        }
+        return context.eventStreamMarshaller;
+    }
 }

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -29,8 +29,27 @@ export class RpcProtocol extends HttpProtocol {
             ...input,
         };
         if (input) {
-            serializer.write(schema, _input);
-            payload = serializer.flush();
+            const eventStreamMember = ns.getEventStreamMember();
+            if (eventStreamMember) {
+                if (_input[eventStreamMember]) {
+                    const initialRequest = {};
+                    for (const [memberName, memberSchema] of ns.structIterator()) {
+                        if (memberName !== eventStreamMember && _input[memberName]) {
+                            serializer.write(memberSchema, _input[memberName]);
+                            initialRequest[memberName] = serializer.flush();
+                        }
+                    }
+                    payload = await this.serializeEventStream({
+                        eventStream: _input[eventStreamMember],
+                        requestSchema: ns,
+                        initialRequest,
+                    });
+                }
+            }
+            else {
+                serializer.write(schema, _input);
+                payload = serializer.flush();
+            }
         }
         request.headers = headers;
         request.query = query;
@@ -55,14 +74,21 @@ export class RpcProtocol extends HttpProtocol {
             delete response.headers[header];
             response.headers[header.toLowerCase()] = value;
         }
-        const bytes = await collectBody(response.body, context);
-        if (bytes.byteLength > 0) {
-            Object.assign(dataObject, await deserializer.read(ns, bytes));
+        const eventStreamMember = ns.getEventStreamMember();
+        if (eventStreamMember) {
+            dataObject[eventStreamMember] = await this.deserializeEventStream({
+                response,
+                responseSchema: ns,
+                initialResponseContainer: dataObject,
+            });
         }
-        const output = {
-            $metadata: this.deserializeMetadata(response),
-            ...dataObject,
-        };
-        return output;
+        else {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                Object.assign(dataObject, await deserializer.read(ns, bytes));
+            }
+        }
+        dataObject.$metadata = this.deserializeMetadata(response);
+        return dataObject;
     }
 }

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/index.js

@@ -1,6 +1,7 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
 export * from "./HttpBindingProtocol";
+export * from "./HttpProtocol";
 export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";

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

@@ -250,6 +250,13 @@ export class NormalizedSchema {
         }
         throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
     }
+    hasMemberSchema(member) {
+        if (this.isStructSchema()) {
+            const struct = this.getSchema();
+            return member in struct.members;
+        }
+        return false;
+    }
     getMemberSchema(member) {
         if (this.isStructSchema()) {
             const struct = this.getSchema();
@@ -278,6 +285,16 @@ export class NormalizedSchema {
         }
         return {};
     }
+    getEventStreamMember() {
+        if (this.isStructSchema()) {
+            for (const [memberName, memberSchema] of this.structIterator()) {
+                if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
+                    return memberName;
+                }
+            }
+        }
+        return "";
+    }
     *structIterator() {
         if (this.isUnitSchema()) {
             return;

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/cbor/CborCodec.d.ts

@@ -1,4 +1,4 @@
-import { Codec, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import type { Codec, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 /**
  * @alpha
  */
@@ -30,5 +30,9 @@ export declare class CborShapeDeserializer implements ShapeDeserializer {
     private serdeContext?;
     setSerdeContext(serdeContext: SerdeFunctions): void;
     read(schema: Schema, bytes: Uint8Array): any;
-    private readValue;
+    /**
+     * Public because it's called by the protocol implementation to deserialize errors.
+     * @internal
+     */
+    readValue(_schema: Schema, value: any): any;
 }

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/cbor/SmithyRpcV2CborProtocol.d.ts

@@ -19,4 +19,5 @@ export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
     serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
     protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected getDefaultContentType(): string;
 }

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

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

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/event-streams/EventStreamSerde.d.ts

@@ -0,0 +1,60 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import type { EventStreamMarshaller, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+/**
+ * Separated module for async mixin of EventStream serde capability.
+ * This is used by the HttpProtocol base class from \@smithy/core/protocols.
+ *
+ * @alpha
+ */
+export declare class EventStreamSerde {
+    private readonly marshaller;
+    private readonly serializer;
+    private readonly deserializer;
+    private readonly serdeContext?;
+    private readonly defaultContentType;
+    /**
+     * Properties are injected by the HttpProtocol.
+     */
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }: {
+        marshaller: EventStreamMarshaller;
+        serializer: ShapeSerializer<string | Uint8Array>;
+        deserializer: ShapeDeserializer<string | Uint8Array>;
+        serdeContext?: SerdeFunctions;
+        defaultContentType: string;
+    });
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    serializeEventStream({ eventStream, requestSchema, initialRequest, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+    }): Promise<IHttpRequest["body"] | Uint8Array>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream for the end-user.
+     */
+    deserializeEventStream({ response, responseSchema, initialResponseContainer, }: {
+        response: IHttpResponse;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * @param unionMember - member name within the structure that contains an event stream union.
+     * @param unionSchema - schema of the union.
+     * @param event
+     *
+     * @returns the event body (bytes) and event type (string).
+     */
+    private writeEventBody;
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/event-streams/index.d.ts

@@ -0,0 +1 @@
+export * from "./EventStreamSerde";

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/HttpBindingProtocol.d.ts

@@ -1,6 +1,6 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest } from "@smithy/protocol-http";
-import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, Schema, SerdeFunctions } from "@smithy/types";
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, Schema, SerdeFunctions } from "@smithy/types";
 import { HttpProtocol } from "./HttpProtocol";
 /**
  * Base for HTTP-binding protocols. Downstream examples

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/HttpProtocol.d.ts

@@ -1,4 +1,6 @@
-import { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import type { EventStreamSerde } from "@smithy/core/event-streams";
+import { NormalizedSchema } from "@smithy/core/schema";
+import type { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, EventStreamMarshaller, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 /**
  * Abstract base for HTTP-based client protocols.
  *
@@ -25,6 +27,41 @@ export declare abstract class HttpProtocol implements ClientProtocol<IHttpReques
     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;
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    protected serializeEventStream({ eventStream, requestSchema, initialRequest, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+    }): Promise<IHttpRequest["body"]>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream.
+     */
+    protected deserializeEventStream({ response, responseSchema, initialResponseContainer, }: {
+        response: IHttpResponse;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * Loads eventStream capability async (for chunking).
+     */
+    protected loadEventStreamCapability(): Promise<EventStreamSerde>;
+    /**
+     * @returns content-type default header value for event stream events and other documents.
+     */
+    protected getDefaultContentType(): string;
     /**
      * For HTTP binding protocols, this method is overridden in {@link HttpBindingProtocol}.
      *
@@ -32,4 +69,5 @@ export declare abstract class HttpProtocol implements ClientProtocol<IHttpReques
      */
     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[]>;
+    protected getEventStreamMarshaller(): EventStreamMarshaller;
 }

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/RpcProtocol.d.ts

@@ -1,4 +1,4 @@
-import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, SerdeFunctions } from "@smithy/types";
+import type { 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.

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
 export * from "./HttpBindingProtocol";
+export * from "./HttpProtocol";
 export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/serde/FromStringShapeDeserializer.d.ts

@@ -1,4 +1,4 @@
-import { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
+import type { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
 /**
  * This deserializer reads strings.
  *

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/serde/HttpInterceptingShapeDeserializer.d.ts

@@ -1,4 +1,4 @@
-import { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
+import type { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
 /**
  * This deserializer is a dispatcher that decides whether to use a string deserializer
  * or a codec deserializer based on HTTP traits.

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/serde/HttpInterceptingShapeSerializer.d.ts

@@ -1,4 +1,4 @@
-import { CodecSettings, Schema as ISchema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
+import type { 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

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/serde/ToStringShapeSerializer.d.ts

@@ -1,4 +1,4 @@
-import { CodecSettings, Schema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
+import type { CodecSettings, Schema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
 /**
  * Serializes a shape to string.
  *

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/protocols/serde/determineTimestampFormat.d.ts

@@ -1,5 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { type TimestampDateTimeSchema, type TimestampEpochSecondsSchema, type TimestampHttpDateSchema, CodecSettings } from "@smithy/types";
+import type { CodecSettings, TimestampDateTimeSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema } 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.

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/schema/middleware/getSchemaSerdePlugin.d.ts

@@ -1,4 +1,4 @@
-import { DeserializeHandlerOptions, MetadataBearer, Pluggable, SerializeHandlerOptions } from "@smithy/types";
+import type { DeserializeHandlerOptions, MetadataBearer, Pluggable, SerializeHandlerOptions } from "@smithy/types";
 import { PreviouslyResolved } from "./schema-middleware-types";
 /**
  * @internal

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-types/submodules/schema/middleware/schemaDeserializationMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { DeserializeHandler, DeserializeHandlerArguments, HandlerExecutionContext } from "@smithy/types";
+import type { DeserializeHandler, DeserializeHandlerArguments, HandlerExecutionContext } from "@smithy/types";
 import { PreviouslyResolved } from "./schema-middleware-types";
 /**
  * @internal