@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -32,9 +32,10 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
                 this.serializer.write(15, {});
                 request.body = this.serializer.flush();
             }
-            if (request.body instanceof Uint8Array) {
+            try {
                 request.headers["content-length"] = String(request.body.byteLength);
             }
+            catch (ignored) { }
         }
         const { service, operation } = getSmithyContext(context);
         const path = `/service/${service}/operation/${operation}`;

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -59,7 +59,7 @@ export function encode(_input) {
             ensureSpace(64);
         }
         if (typeof input === "number") {
-            if (Number.isInteger(input) && input >= -0x20000000000000 && input <= 0x1fffffffffffff) {
+            if (Number.isInteger(input)) {
                 const nonNegative = input >= 0;
                 const major = nonNegative ? majorUint64 : majorNegativeInt64;
                 const value = nonNegative ? input : -input - 1;

package/node_modules/@smithy/core/dist-es/submodules/cbor/index.js

@@ -2,8 +2,4 @@ export { cbor } from "./cbor";
 export { tag, tagSymbol } from "./cbor-types";
 export { buildHttpRpcRequest, checkCborResponse, dateToTag, loadSmithyRpcV2CborErrorCode, parseCborBody, parseCborErrorBody, } from "./parseCborBody";
 export { SmithyRpcV2CborProtocol } from "./SmithyRpcV2CborProtocol";
-export { CborCodec } from "./CborCodec";
-export { CborShapeSerializer } from "./codec-v1/CborShapeSerializer";
-export { CborShapeDeserializer } from "./codec-v1/CborShapeDeserializer";
-export { CborShapeSerializer2 } from "./codec-v2/CborShapeSerializer2";
-export { CborShapeDeserializer2 } from "./codec-v2/CborShapeDeserializer2";
+export { CborCodec, CborShapeDeserializer, CborShapeSerializer } from "./CborCodec";

package/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -15,7 +15,7 @@ export class EventStreamSerde {
         this.defaultContentType = defaultContentType;
         this.compositeErrorRegistry = compositeErrorRegistry;
     }
-    async serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType, }) {
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
         const marshaller = this.marshaller;
         const eventStreamMember = requestSchema.getEventStreamMember();
         const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
@@ -26,7 +26,7 @@ export class EventStreamSerde {
             async *[Symbol.asyncIterator]() {
                 if (initialRequest) {
                     const headers = {
-                        ":event-type": { type: "string", value: initialMessageType ?? "initial-request" },
+                        ":event-type": { type: "string", value: "initial-request" },
                         ":message-type": { type: "string", value: "event" },
                         ":content-type": { type: "string", value: defaultContentType },
                     };
@@ -70,7 +70,7 @@ export class EventStreamSerde {
             };
         });
     }
-    async deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType, }) {
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
         const marshaller = this.marshaller;
         const eventStreamMember = responseSchema.getEventStreamMember();
         const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
@@ -85,7 +85,7 @@ export class EventStreamSerde {
                 }
             }
             const body = event[unionMember].body;
-            if (unionMember === (initialMessageType ?? "initial-response")) {
+            if (unionMember === "initial-response") {
                 const dataObject = await this.deserializer.read(responseSchema, body);
                 delete dataObject[eventStreamMember];
                 return {

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/HeaderMarshaller.js

@@ -24,27 +24,27 @@ export class HeaderMarshaller {
     formatHeaderValue(header) {
         switch (header.type) {
             case "boolean":
-                return Uint8Array.from([header.value ? 0 : 1]);
+                return Uint8Array.from([header.value ? HEADER_VALUE_TYPE.boolTrue : HEADER_VALUE_TYPE.boolFalse]);
             case "byte":
-                return Uint8Array.from([2, header.value]);
+                return Uint8Array.from([HEADER_VALUE_TYPE.byte, header.value]);
             case "short":
                 const shortView = new DataView(new ArrayBuffer(3));
-                shortView.setUint8(0, 3);
+                shortView.setUint8(0, HEADER_VALUE_TYPE.short);
                 shortView.setInt16(1, header.value, false);
                 return new Uint8Array(shortView.buffer);
             case "integer":
                 const intView = new DataView(new ArrayBuffer(5));
-                intView.setUint8(0, 4);
+                intView.setUint8(0, HEADER_VALUE_TYPE.integer);
                 intView.setInt32(1, header.value, false);
                 return new Uint8Array(intView.buffer);
             case "long":
                 const longBytes = new Uint8Array(9);
-                longBytes[0] = 5;
+                longBytes[0] = HEADER_VALUE_TYPE.long;
                 longBytes.set(header.value.bytes, 1);
                 return longBytes;
             case "binary":
                 const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
-                binView.setUint8(0, 6);
+                binView.setUint8(0, HEADER_VALUE_TYPE.byteArray);
                 binView.setUint16(1, header.value.byteLength, false);
                 const binBytes = new Uint8Array(binView.buffer);
                 binBytes.set(header.value, 3);
@@ -52,14 +52,14 @@ export class HeaderMarshaller {
             case "string":
                 const utf8Bytes = this.fromUtf8(header.value);
                 const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
-                strView.setUint8(0, 7);
+                strView.setUint8(0, HEADER_VALUE_TYPE.string);
                 strView.setUint16(1, utf8Bytes.byteLength, false);
                 const strBytes = new Uint8Array(strView.buffer);
                 strBytes.set(utf8Bytes, 3);
                 return strBytes;
             case "timestamp":
                 const tsBytes = new Uint8Array(9);
-                tsBytes[0] = 8;
+                tsBytes[0] = HEADER_VALUE_TYPE.timestamp;
                 tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
                 return tsBytes;
             case "uuid":
@@ -67,7 +67,7 @@ export class HeaderMarshaller {
                     throw new Error(`Invalid UUID received: ${header.value}`);
                 }
                 const uuidBytes = new Uint8Array(17);
-                uuidBytes[0] = 9;
+                uuidBytes[0] = HEADER_VALUE_TYPE.uuid;
                 uuidBytes.set(fromHex(header.value.replace(/-/g, "")), 1);
                 return uuidBytes;
         }
@@ -80,46 +80,46 @@ export class HeaderMarshaller {
             const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
             position += nameLength;
             switch (headers.getUint8(position++)) {
-                case 0:
+                case HEADER_VALUE_TYPE.boolTrue:
                     out[name] = {
                         type: BOOLEAN_TAG,
                         value: true,
                     };
                     break;
-                case 1:
+                case HEADER_VALUE_TYPE.boolFalse:
                     out[name] = {
                         type: BOOLEAN_TAG,
                         value: false,
                     };
                     break;
-                case 2:
+                case HEADER_VALUE_TYPE.byte:
                     out[name] = {
                         type: BYTE_TAG,
                         value: headers.getInt8(position++),
                     };
                     break;
-                case 3:
+                case HEADER_VALUE_TYPE.short:
                     out[name] = {
                         type: SHORT_TAG,
                         value: headers.getInt16(position, false),
                     };
                     position += 2;
                     break;
-                case 4:
+                case HEADER_VALUE_TYPE.integer:
                     out[name] = {
                         type: INT_TAG,
                         value: headers.getInt32(position, false),
                     };
                     position += 4;
                     break;
-                case 5:
+                case HEADER_VALUE_TYPE.long:
                     out[name] = {
                         type: LONG_TAG,
                         value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)),
                     };
                     position += 8;
                     break;
-                case 6:
+                case HEADER_VALUE_TYPE.byteArray:
                     const binaryLength = headers.getUint16(position, false);
                     position += 2;
                     out[name] = {
@@ -128,7 +128,7 @@ export class HeaderMarshaller {
                     };
                     position += binaryLength;
                     break;
-                case 7:
+                case HEADER_VALUE_TYPE.string:
                     const stringLength = headers.getUint16(position, false);
                     position += 2;
                     out[name] = {
@@ -137,14 +137,14 @@ export class HeaderMarshaller {
                     };
                     position += stringLength;
                     break;
-                case 8:
+                case HEADER_VALUE_TYPE.timestamp:
                     out[name] = {
                         type: TIMESTAMP_TAG,
                         value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf()),
                     };
                     position += 8;
                     break;
-                case 9:
+                case HEADER_VALUE_TYPE.uuid:
                     const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
                     position += 16;
                     out[name] = {

package/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -31,9 +31,10 @@ export class RpcProtocol extends HttpProtocol {
             if (eventStreamMember) {
                 if (input[eventStreamMember]) {
                     const initialRequest = {};
-                    for (const [memberName] of ns.structIterator()) {
-                        if (memberName !== eventStreamMember && input[memberName] != null) {
-                            initialRequest[memberName] = input[memberName];
+                    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({

package/node_modules/@smithy/core/dist-es/submodules/protocols/middleware-content-length/contentLengthMiddleware.js

@@ -11,12 +11,10 @@ export function contentLengthMiddleware(bodyLengthChecker) {
                     .indexOf(CONTENT_LENGTH_HEADER) === -1) {
                 try {
                     const length = bodyLengthChecker(body);
-                    if (length != null) {
-                        request.headers = {
-                            ...request.headers,
-                            [CONTENT_LENGTH_HEADER]: String(length),
-                        };
-                    }
+                    request.headers = {
+                        ...request.headers,
+                        [CONTENT_LENGTH_HEADER]: String(length),
+                    };
                 }
                 catch (ignored) {
                 }

package/node_modules/@smithy/core/dist-es/submodules/protocols/protocol-http/extensions/httpExtensionConfiguration.js

@@ -1,24 +1,21 @@
 export const getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
-    if (runtimeConfig.logger && runtimeConfig.logger.constructor?.name !== "NoOpLogger") {
-        runtimeConfig.requestHandler?.updateHttpClientConfig?.(Symbol.for("logger"), runtimeConfig.logger);
-    }
     return {
         setHttpHandler(handler) {
-            runtimeConfig.requestHandler = handler;
+            runtimeConfig.httpHandler = handler;
         },
         httpHandler() {
-            return runtimeConfig.requestHandler;
+            return runtimeConfig.httpHandler;
         },
         updateHttpClientConfig(key, value) {
-            runtimeConfig.requestHandler?.updateHttpClientConfig(key, value);
+            runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
         },
         httpHandlerConfigs() {
-            return runtimeConfig.requestHandler.httpHandlerConfigs();
+            return runtimeConfig.httpHandler.httpHandlerConfigs();
         },
     };
 };
 export const resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
     return {
-        requestHandler: httpHandlerExtensionConfiguration.httpHandler(),
+        httpHandler: httpHandlerExtensionConfiguration.httpHandler(),
     };
 };

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js

@@ -1,6 +1,8 @@
 import { Schema } from "./Schema";
 export class ListSchema extends Schema {
     static symbol = Symbol.for("@smithy/lis");
+    name;
+    traits;
     valueSchema;
     symbol = ListSchema.symbol;
 }

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js

@@ -1,6 +1,8 @@
 import { Schema } from "./Schema";
 export class MapSchema extends Schema {
     static symbol = Symbol.for("@smithy/map");
+    name;
+    traits;
     keySchema;
     valueSchema;
     symbol = MapSchema.symbol;

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js

@@ -1,6 +1,8 @@
 import { Schema } from "./Schema";
 export class OperationSchema extends Schema {
     static symbol = Symbol.for("@smithy/ope");
+    name;
+    traits;
     input;
     output;
     symbol = OperationSchema.symbol;

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js

@@ -1,7 +1,9 @@
 import { Schema } from "./Schema";
 export class SimpleSchema extends Schema {
     static symbol = Symbol.for("@smithy/sim");
+    name;
     schemaRef;
+    traits;
     symbol = SimpleSchema.symbol;
 }
 export const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js

@@ -1,6 +1,8 @@
 import { Schema } from "./Schema";
 export class StructureSchema extends Schema {
     static symbol = Symbol.for("@smithy/str");
+    name;
+    traits;
     memberNames;
     memberList;
     symbol = StructureSchema.symbol;

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

@@ -1,11 +1,33 @@
 import { SerdeContext } from "@smithy/core/protocols";
-import type { Codec } from "@smithy/types";
-import { CborShapeSerializer2 } from "./codec-v2/CborShapeSerializer2";
-import { CborShapeDeserializer2 } from "./codec-v2/CborShapeDeserializer2";
+import type { Codec, Schema, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 /**
  * @public
  */
 export declare class CborCodec extends SerdeContext implements Codec<Uint8Array, Uint8Array> {
-    createSerializer(): CborShapeSerializer2;
-    createDeserializer(): CborShapeDeserializer2;
+    createSerializer(): CborShapeSerializer;
+    createDeserializer(): CborShapeDeserializer;
+}
+/**
+ * @public
+ */
+export declare class CborShapeSerializer extends SerdeContext implements ShapeSerializer {
+    private value;
+    write(schema: Schema, value: unknown): void;
+    /**
+     * Recursive serializer transform that copies and prepares the user input object
+     * for CBOR serialization.
+     */
+    serialize(schema: Schema, source: unknown): any;
+    flush(): Uint8Array;
+}
+/**
+ * @public
+ */
+export declare class CborShapeDeserializer extends SerdeContext implements ShapeDeserializer {
+    read(schema: Schema, bytes: Uint8Array): any;
+    /**
+     * Public because it's called by the protocol implementation to deserialize errors.
+     * @internal
+     */
+    readValue(_schema: Schema, value: any): any;
 }

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

@@ -13,8 +13,8 @@ export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
      */
     protected compositeErrorRegistry: TypeRegistry;
     private codec;
-    protected serializer: import(".").CborShapeSerializer2;
-    protected deserializer: import(".").CborShapeDeserializer2;
+    protected serializer: import("./CborCodec").CborShapeSerializer;
+    protected deserializer: import("./CborCodec").CborShapeDeserializer;
     constructor({ defaultNamespace, errorTypeRegistries, }: {
         defaultNamespace: string;
         errorTypeRegistries?: TypeRegistry[];

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

@@ -2,8 +2,4 @@ export { cbor } from "./cbor";
 export { tag, tagSymbol } from "./cbor-types";
 export { buildHttpRpcRequest, checkCborResponse, dateToTag, loadSmithyRpcV2CborErrorCode, parseCborBody, parseCborErrorBody, } from "./parseCborBody";
 export { SmithyRpcV2CborProtocol } from "./SmithyRpcV2CborProtocol";
-export { CborCodec } from "./CborCodec";
-export { CborShapeSerializer } from "./codec-v1/CborShapeSerializer";
-export { CborShapeDeserializer } from "./codec-v1/CborShapeDeserializer";
-export { CborShapeSerializer2 } from "./codec-v2/CborShapeSerializer2";
-export { CborShapeDeserializer2 } from "./codec-v2/CborShapeDeserializer2";
+export { CborCodec, CborShapeDeserializer, CborShapeSerializer } from "./CborCodec";

package/node_modules/@smithy/core/dist-types/submodules/client/smithy-client/extensions/defaultExtensionConfiguration.d.ts

@@ -23,7 +23,13 @@ export declare const getDefaultExtensionConfiguration: (runtimeConfig: DefaultEx
  * @internal
  * @deprecated use getDefaultExtensionConfiguration
  */
-export declare const getDefaultClientConfiguration: typeof getDefaultExtensionConfiguration;
+export declare const getDefaultClientConfiguration: (runtimeConfig: DefaultExtensionRuntimeConfigType) => {
+    addChecksumAlgorithm(algo: import("@smithy/types").ChecksumAlgorithm): void;
+    checksumAlgorithms(): import("@smithy/types").ChecksumAlgorithm[];
+} & {
+    setRetryStrategy(retryStrategy: import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>): void;
+    retryStrategy(): import("@smithy/types").Provider<import("@smithy/types").RetryStrategyV2 | import("@smithy/types").RetryStrategy>;
+};
 /**
  * Helper function to resolve runtime config from default extension configuration
  *

package/node_modules/@smithy/core/dist-types/submodules/config/config-resolver/regionConfig/checkRegion.d.ts

@@ -1,4 +1,3 @@
-import { isValidHostLabel } from "@smithy/core/transport";
 /**
  * Checks whether region can be a host component.
  *
@@ -7,4 +6,4 @@ import { isValidHostLabel } from "@smithy/core/transport";
  *
  * @internal
  */
-export declare const checkRegion: (region: string, check?: typeof isValidHostLabel) => void;
+export declare const checkRegion: (region: string, check?: (value: string, allowSubDomains?: boolean) => boolean) => void;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateCondition.d.ts

@@ -6,6 +6,6 @@ export declare const evaluateCondition: (condition: ConditionObject, options: Ev
         value: import("../types").FunctionReturn;
     };
 } | {
-    toAssign?: undefined;
     result: boolean;
+    toAssign?: undefined;
 };

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateConditions.d.ts

@@ -3,6 +3,6 @@ export declare const evaluateConditions: (conditions: ConditionObject[] | undefi
     result: boolean;
     referenceRecord: Record<string, FunctionReturn>;
 } | {
-    referenceRecord?: undefined;
     result: boolean;
+    referenceRecord?: undefined;
 };

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateExpression.d.ts

@@ -2,6 +2,6 @@ import { type EvaluateOptions, type Expression, type FunctionObject, type Functi
 export declare const evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
 export declare const callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
 export declare const group: {
-    evaluateExpression: typeof evaluateExpression;
-    callFunction: typeof callFunction;
+    evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
+    callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
 };

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateRules.d.ts

@@ -3,6 +3,6 @@ import { type EvaluateOptions, type RuleSetRules, type TreeRuleObject } from "..
 export declare const evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
 export declare const evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
 export declare const group: {
-    evaluateRules: typeof evaluateRules;
-    evaluateTreeRule: typeof evaluateTreeRule;
+    evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
+    evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
 };

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/getEndpointProperties.d.ts

@@ -3,6 +3,6 @@ import { type EndpointObjectProperties, type EvaluateOptions } from "../types";
 export declare const getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
 export declare const getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
 export declare const group: {
-    getEndpointProperty: typeof getEndpointProperty;
-    getEndpointProperties: typeof getEndpointProperties;
+    getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+    getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
 };

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/getReferenceValue.d.ts

@@ -1,4 +1,4 @@
 import type { EvaluateOptions, ReferenceObject } from "../types";
-export declare const getReferenceValue: ({ ref }: ReferenceObject, options: EvaluateOptions) => string | number | boolean | import("../types").FunctionReturn[] | import("@smithy/types").EndpointARN | import("@smithy/types").EndpointPartition | import("@smithy/types").EndpointURL | {
+export declare const getReferenceValue: ({ ref }: ReferenceObject, options: EvaluateOptions) => string | number | boolean | import("@smithy/types").EndpointPartition | import("@smithy/types").EndpointARN | import("@smithy/types").EndpointURL | {
     [key: string]: import("../types").FunctionReturn;
-};
+} | import("../types").FunctionReturn[];

package/node_modules/@smithy/core/dist-types/submodules/event-streams/EventStreamSerde.d.ts

@@ -31,16 +31,10 @@ export declare class EventStreamSerde {
      *
      * @returns a stream suitable for the HTTP body of a request.
      */
-    serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType, }: {
+    serializeEventStream({ eventStream, requestSchema, initialRequest, }: {
         eventStream: AsyncIterable<any>;
         requestSchema: NormalizedSchema;
         initialRequest?: any;
-        /**
-         * The :event-type header value for the initial message.
-         * Defaults to "initial-request" (client→server).
-         * Server→client should pass "initial-response".
-         */
-        initialMessageType?: string;
     }): Promise<IHttpRequest["body"] | Uint8Array>;
     /**
      * @param response - http response from which to read the event stream.
@@ -49,16 +43,10 @@ export declare class EventStreamSerde {
      *
      * @returns the asyncIterable of the event stream for the end-user.
      */
-    deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType, }: {
+    deserializeEventStream({ response, responseSchema, initialResponseContainer, }: {
         response: IHttpResponse;
         responseSchema: NormalizedSchema;
         initialResponseContainer?: any;
-        /**
-         * The :event-type header value to match as the initial message.
-         * Defaults to "initial-response" (server→client).
-         * Server-side deserialization of client requests should pass "initial-request".
-         */
-        initialMessageType?: string;
     }): Promise<AsyncIterable<{
         [key: string]: any;
         $unknown?: unknown;

package/node_modules/@smithy/core/dist-types/submodules/protocols/protocol-http/extensions/httpExtensionConfiguration.d.ts

@@ -1,4 +1,3 @@
-import type { Logger } from "@smithy/types";
 import type { HttpHandler } from "../httpHandler";
 /**
  * @internal
@@ -13,18 +12,14 @@ export interface HttpHandlerExtensionConfiguration<HandlerConfig extends object
  * @internal
  */
 export type HttpHandlerExtensionConfigType<HandlerConfig extends object = {}> = Partial<{
-    requestHandler: HttpHandler<HandlerConfig>;
+    httpHandler: HttpHandler<HandlerConfig>;
 }>;
 /**
  * Helper function to resolve default extension configuration from runtime config
  *
  * @internal
  */
-export declare const getHttpHandlerExtensionConfiguration: <HandlerConfig extends {
-    logger?: Logger;
-}>(runtimeConfig: HttpHandlerExtensionConfigType<HandlerConfig> & {
-    logger?: Logger;
-}) => {
+export declare const getHttpHandlerExtensionConfiguration: <HandlerConfig extends object = {}>(runtimeConfig: HttpHandlerExtensionConfigType<HandlerConfig>) => {
     setHttpHandler(handler: HttpHandler<HandlerConfig>): void;
     httpHandler(): HttpHandler<HandlerConfig>;
     updateHttpClientConfig(key: keyof HandlerConfig, value: HandlerConfig[typeof key]): void;

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

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

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

@@ -62,7 +62,7 @@ export declare class TypeRegistry {
      * @param predicate - criterion.
      * @returns a schema in this registry matching the predicate.
      */
-    find(predicate: (schema: ISchema) => boolean): number | "unit" | import("@smithy/types").MemberSchema | import("@smithy/types").NormalizedSchema | StaticErrorSchema | import("@smithy/types").StaticListSchema | import("@smithy/types").StaticMapSchema | import("@smithy/types").StaticOperationSchema | import("@smithy/types").StaticSimpleSchema | import("@smithy/types").StaticStructureSchema | import("@smithy/types").StaticUnionSchema | import("@smithy/types").TraitsSchema | undefined;
+    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.
      */

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

@@ -51,7 +51,7 @@ export declare const expectLong: (value: any) => number | undefined;
  *
  * @deprecated Use expectLong
  */
-export declare const expectInt: typeof expectLong;
+export declare const expectInt: (value: any) => number | undefined;
 /**
  * Asserts a value is a 32-bit integer and returns it.
  * otherwise an error is thrown.
@@ -136,7 +136,7 @@ export declare const strictParseDouble: (value: string | number) => number | und
  *
  * @deprecated Use strictParseDouble
  */
-export declare const strictParseFloat: typeof strictParseDouble;
+export declare const strictParseFloat: (value: string | number) => number | undefined;
 /**
  * Parses a value into a float. If the value is null or undefined, undefined
  * will be returned. If the value is a string, it will be parsed by the standard
@@ -166,13 +166,13 @@ export declare const limitedParseDouble: (value: string | number) => number | un
  *
  * @deprecated Use limitedParseDouble
  */
-export declare const handleFloat: typeof limitedParseDouble;
+export declare const handleFloat: (value: string | number) => number | undefined;
 /**
  * @internal
  *
  * @deprecated Use limitedParseDouble
  */
-export declare const limitedParseFloat: typeof limitedParseDouble;
+export declare const limitedParseFloat: (value: string | number) => number | undefined;
 /**
  * Asserts a value is a 32-bit float and returns it. If the value is a string
  * representation of a non-numeric number type (NaN, Infinity, -Infinity),
@@ -202,7 +202,7 @@ export declare const strictParseLong: (value: string | number) => number | undef
  *
  * @deprecated Use strictParseLong
  */
-export declare const strictParseInt: typeof strictParseLong;
+export declare const strictParseInt: (value: string | number) => number | undefined;
 /**
  * Parses a value into a 32-bit integer. If the value is null or undefined, undefined
  * will be returned. If the value is a string, it will be parsed by parseFloat