@gemeentenijmegen/webapp 1.1.10 → 1.1.12

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ProtocolLib.js

@@ -0,0 +1,89 @@
+import { TypeRegistry } from "@smithy/core/schema";
+export class ProtocolLib {
+    resolveRestContentType(defaultContentType, inputSchema) {
+        const members = inputSchema.getMemberSchemas();
+        const httpPayloadMember = Object.values(members).find((m) => {
+            return !!m.getMergedTraits().httpPayload;
+        });
+        if (httpPayloadMember) {
+            const mediaType = httpPayloadMember.getMergedTraits().mediaType;
+            if (mediaType) {
+                return mediaType;
+            }
+            else if (httpPayloadMember.isStringSchema()) {
+                return "text/plain";
+            }
+            else if (httpPayloadMember.isBlobSchema()) {
+                return "application/octet-stream";
+            }
+            else {
+                return defaultContentType;
+            }
+        }
+        else if (!inputSchema.isUnitSchema()) {
+            const hasBody = Object.values(members).find((m) => {
+                const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
+                const noPrefixHeaders = httpPrefixHeaders === void 0;
+                return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders;
+            });
+            if (hasBody) {
+                return defaultContentType;
+            }
+        }
+    }
+    async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) {
+        let namespace = defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const errorMetadata = {
+            $metadata: metadata,
+            $response: response,
+            $fault: response.statusCode < 500 ? "client" : "server",
+        };
+        const registry = TypeRegistry.for(namespace);
+        try {
+            const errorSchema = getErrorSchema?.(registry, errorName) ?? registry.getSchema(errorIdentifier);
+            return { errorSchema, errorMetadata };
+        }
+        catch (e) {
+            dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError";
+            const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            const baseExceptionSchema = synthetic.getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error;
+                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            }
+            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
+        }
+    }
+    setQueryCompatError(output, response) {
+        const queryErrorHeader = response.headers?.["x-amzn-query-error"];
+        if (output !== undefined && queryErrorHeader != null) {
+            const [Code, Type] = queryErrorHeader.split(";");
+            const entries = Object.entries(output);
+            const Error = {
+                Code,
+                Type,
+            };
+            Object.assign(output, Error);
+            for (const [k, v] of entries) {
+                Error[k] = v;
+            }
+            delete Error.__type;
+            output.Error = Error;
+        }
+    }
+    queryCompatOutput(queryCompatErrorData, errorData) {
+        if (queryCompatErrorData.Error) {
+            errorData.Error = queryCompatErrorData.Error;
+        }
+        if (queryCompatErrorData.Type) {
+            errorData.Type = queryCompatErrorData.Type;
+        }
+        if (queryCompatErrorData.Code) {
+            errorData.Code = queryCompatErrorData.Code;
+        }
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/cbor/AwsSmithyRpcV2CborProtocol.js

@@ -0,0 +1,40 @@
+import { loadSmithyRpcV2CborErrorCode, SmithyRpcV2CborProtocol } from "@smithy/core/cbor";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
+export class AwsSmithyRpcV2CborProtocol extends SmithyRpcV2CborProtocol {
+    awsQueryCompatible;
+    mixin = new ProtocolLib();
+    constructor({ defaultNamespace, awsQueryCompatible, }) {
+        super({ defaultNamespace });
+        this.awsQueryCompatible = !!awsQueryCompatible;
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        if (this.awsQueryCompatible) {
+            request.headers["x-amzn-query-mode"] = "true";
+        }
+        return request;
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        if (this.awsQueryCompatible) {
+            this.mixin.setQueryCompatError(dataObject, response);
+        }
+        const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata);
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const ErrorCtor = TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error;
+        const exception = new ErrorCtor(message);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            output[name] = this.deserializer.readValue(member, dataObject[name]);
+        }
+        if (this.awsQueryCompatible) {
+            this.mixin.queryCompatOutput(dataObject, output);
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
+            message,
+        }, output);
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js

@@ -1,2 +1,3 @@
 import { collectBody } from "@smithy/smithy-client";
-export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+import { toUtf8 } from "@smithy/util-utf8";
+export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js

@@ -1,3 +1,4 @@
+export * from "./cbor/AwsSmithyRpcV2CborProtocol";
 export * from "./coercing-serializers";
 export * from "./json/AwsJson1_0Protocol";
 export * from "./json/AwsJson1_1Protocol";

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_0Protocol.js

@@ -1,8 +1,10 @@
 import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
 export class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace }) {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
+            serviceTarget,
+            awsQueryCompatible,
         });
     }
     getShapeId() {
@@ -11,4 +13,7 @@ export class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
     getJsonRpcVersion() {
         return "1.0";
     }
+    getDefaultContentType() {
+        return "application/x-amz-json-1.0";
+    }
 }

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_1Protocol.js

@@ -1,8 +1,10 @@
 import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
 export class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace }) {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
+            serviceTarget,
+            awsQueryCompatible,
         });
     }
     getShapeId() {
@@ -11,4 +13,7 @@ export class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
     getJsonRpcVersion() {
         return "1.1";
     }
+    getDefaultContentType() {
+        return "application/x-amz-json-1.1";
+    }
 }

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJsonRpcProtocol.js

@@ -1,25 +1,30 @@
 import { RpcProtocol } from "@smithy/core/protocols";
-import { deref, NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { deref, NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { JsonCodec } from "./JsonCodec";
 import { loadRestJsonErrorCode } from "./parseJsonBody";
 export class AwsJsonRpcProtocol extends RpcProtocol {
     serializer;
     deserializer;
+    serviceTarget;
     codec;
-    constructor({ defaultNamespace }) {
+    mixin = new ProtocolLib();
+    awsQueryCompatible;
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
         });
+        this.serviceTarget = serviceTarget;
         this.codec = new JsonCodec({
             timestampFormat: {
                 useTrait: true,
-                default: SCHEMA.TIMESTAMP_EPOCH_SECONDS,
+                default: 7,
             },
             jsonName: false,
         });
         this.serializer = this.codec.createSerializer();
         this.deserializer = this.codec.createDeserializer();
+        this.awsQueryCompatible = !!awsQueryCompatible;
     }
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
@@ -28,57 +33,40 @@ export class AwsJsonRpcProtocol extends RpcProtocol {
         }
         Object.assign(request.headers, {
             "content-type": `application/x-amz-json-${this.getJsonRpcVersion()}`,
-            "x-amz-target": (this.getJsonRpcVersion() === "1.0" ? `JsonRpc10.` : `JsonProtocol.`) +
-                NormalizedSchema.of(operationSchema).getName(),
+            "x-amz-target": `${this.serviceTarget}.${operationSchema.name}`,
         });
+        if (this.awsQueryCompatible) {
+            request.headers["x-amzn-query-mode"] = "true";
+        }
         if (deref(operationSchema.input) === "unit" || !request.body) {
             request.body = "{}";
         }
-        try {
-            request.headers["content-length"] = String(calculateBodyLength(request.body));
-        }
-        catch (e) { }
         return request;
     }
     getPayloadCodec() {
         return this.codec;
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
-        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorIdentifier);
-        }
-        catch (e) {
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor(errorName), dataObject);
-            }
-            throw new Error(errorName);
+        if (this.awsQueryCompatible) {
+            this.mixin.setQueryCompatError(dataObject, response);
         }
+        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
-        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        const ErrorCtor = TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error;
+        const exception = new ErrorCtor(message);
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             const target = member.getMergedTraits().jsonName ?? name;
             output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]);
         }
-        Object.assign(exception, {
-            $metadata: metadata,
-            $response: response,
+        if (this.awsQueryCompatible) {
+            this.mixin.queryCompatOutput(dataObject, output);
+        }
+        throw Object.assign(exception, errorMetadata, {
             $fault: ns.getMergedTraits().error,
             message,
-            ...output,
-        });
-        throw exception;
+        }, output);
     }
 }

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsRestJsonProtocol.js

@@ -1,12 +1,13 @@
 import { HttpBindingProtocol, HttpInterceptingShapeDeserializer, HttpInterceptingShapeSerializer, } from "@smithy/core/protocols";
-import { NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { JsonCodec } from "./JsonCodec";
 import { loadRestJsonErrorCode } from "./parseJsonBody";
 export class AwsRestJsonProtocol extends HttpBindingProtocol {
     serializer;
     deserializer;
     codec;
+    mixin = new ProtocolLib();
     constructor({ defaultNamespace }) {
         super({
             defaultNamespace,
@@ -14,7 +15,7 @@ export class AwsRestJsonProtocol extends HttpBindingProtocol {
         const settings = {
             timestampFormat: {
                 useTrait: true,
-                default: SCHEMA.TIMESTAMP_EPOCH_SECONDS,
+                default: 7,
             },
             httpBindings: true,
             jsonName: true,
@@ -36,83 +37,36 @@ export class AwsRestJsonProtocol extends HttpBindingProtocol {
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
         const inputSchema = NormalizedSchema.of(operationSchema.input);
-        const members = inputSchema.getMemberSchemas();
         if (!request.headers["content-type"]) {
-            const httpPayloadMember = Object.values(members).find((m) => {
-                return !!m.getMergedTraits().httpPayload;
-            });
-            if (httpPayloadMember) {
-                const mediaType = httpPayloadMember.getMergedTraits().mediaType;
-                if (mediaType) {
-                    request.headers["content-type"] = mediaType;
-                }
-                else if (httpPayloadMember.isStringSchema()) {
-                    request.headers["content-type"] = "text/plain";
-                }
-                else if (httpPayloadMember.isBlobSchema()) {
-                    request.headers["content-type"] = "application/octet-stream";
-                }
-                else {
-                    request.headers["content-type"] = "application/json";
-                }
-            }
-            else if (!inputSchema.isUnitSchema()) {
-                const hasBody = Object.values(members).find((m) => {
-                    const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
-                    return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
-                });
-                if (hasBody) {
-                    request.headers["content-type"] = "application/json";
-                }
+            const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
+            if (contentType) {
+                request.headers["content-type"] = contentType;
             }
         }
         if (request.headers["content-type"] && !request.body) {
             request.body = "{}";
         }
-        if (request.body) {
-            try {
-                request.headers["content-length"] = String(calculateBodyLength(request.body));
-            }
-            catch (e) { }
-        }
         return request;
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorIdentifier);
-        }
-        catch (e) {
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor(errorName), dataObject);
-            }
-            throw new Error(errorName);
-        }
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
+        const ErrorCtor = TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error;
+        const exception = new ErrorCtor(message);
         await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             const target = member.getMergedTraits().jsonName ?? name;
             output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]);
         }
-        Object.assign(exception, {
-            $metadata: metadata,
-            $response: response,
+        throw Object.assign(exception, errorMetadata, {
             $fault: ns.getMergedTraits().error,
             message,
-            ...output,
-        });
-        throw exception;
+        }, output);
+    }
+    getDefaultContentType() {
+        return "application/json";
     }
 }

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeDeserializer.js

@@ -1,4 +1,5 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { determineTimestampFormat } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
 import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, } from "@smithy/core/serde";
 import { fromBase64 } from "@smithy/util-base64";
 import { SerdeContextConfig } from "../ConfigurableSerdeContext";
@@ -62,19 +63,14 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
                 return LazyJsonString.from(value);
             }
         }
-        if (ns.isTimestampSchema()) {
-            const options = this.settings.timestampFormat;
-            const format = options.useTrait
-                ? ns.getSchema() === SCHEMA.TIMESTAMP_DEFAULT
-                    ? options.default
-                    : ns.getSchema() ?? options.default
-                : options.default;
+        if (ns.isTimestampSchema() && value != null) {
+            const format = determineTimestampFormat(ns, this.settings);
             switch (format) {
-                case SCHEMA.TIMESTAMP_DATE_TIME:
+                case 5:
                     return parseRfc3339DateTimeWithOffset(value);
-                case SCHEMA.TIMESTAMP_HTTP_DATE:
+                case 6:
                     return parseRfc7231DateTime(value);
-                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                case 7:
                     return parseEpochTimestamp(value);
                 default:
                     console.warn("Missing timestamp format, parsing value with Date constructor:", value);
@@ -88,6 +84,10 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
             if (value instanceof NumericValue) {
                 return value;
             }
+            const untyped = value;
+            if (untyped.type === "bigDecimal" && "string" in untyped) {
+                return new NumericValue(untyped.string, untyped.type);
+            }
             return new NumericValue(String(value), "bigDecimal");
         }
         if (ns.isNumericSchema() && typeof value === "string") {
@@ -100,6 +100,23 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
                     return NaN;
             }
         }
+        if (ns.isDocumentSchema()) {
+            if (isObject) {
+                const out = Array.isArray(value) ? [] : {};
+                for (const [k, v] of Object.entries(value)) {
+                    if (v instanceof NumericValue) {
+                        out[k] = v;
+                    }
+                    else {
+                        out[k] = this._read(ns, v);
+                    }
+                }
+                return out;
+            }
+            else {
+                return structuredClone(value);
+            }
+        }
         return value;
     }
 }

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeSerializer.js

@@ -1,6 +1,7 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
-import { dateToUtcString } from "@smithy/core/serde";
-import { LazyJsonString } from "@smithy/core/serde";
+import { determineTimestampFormat } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { dateToUtcString, generateIdempotencyToken, LazyJsonString, NumericValue } from "@smithy/core/serde";
+import { toBase64 } from "@smithy/util-base64";
 import { SerdeContextConfig } from "../ConfigurableSerdeContext";
 import { JsonReplacer } from "./jsonReplacer";
 export class JsonShapeSerializer extends SerdeContextConfig {
@@ -15,8 +16,16 @@ export class JsonShapeSerializer extends SerdeContextConfig {
         this.rootSchema = NormalizedSchema.of(schema);
         this.buffer = this._write(this.rootSchema, value);
     }
+    writeDiscriminatedDocument(schema, value) {
+        this.write(schema, value);
+        if (typeof this.buffer === "object") {
+            this.buffer.__type = NormalizedSchema.of(schema).getName(true);
+        }
+    }
     flush() {
-        if (this.rootSchema?.isStructSchema() || this.rootSchema?.isDocumentSchema()) {
+        const { rootSchema } = this;
+        this.rootSchema = undefined;
+        if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) {
             const replacer = new JsonReplacer();
             return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0));
         }
@@ -61,28 +70,24 @@ export class JsonShapeSerializer extends SerdeContextConfig {
         if (value === null && container?.isStructSchema()) {
             return void 0;
         }
-        if (ns.isBlobSchema() && (value instanceof Uint8Array || typeof value === "string")) {
+        if ((ns.isBlobSchema() && (value instanceof Uint8Array || typeof value === "string")) ||
+            (ns.isDocumentSchema() && value instanceof Uint8Array)) {
             if (ns === this.rootSchema) {
                 return value;
             }
             if (!this.serdeContext?.base64Encoder) {
-                throw new Error("Missing base64Encoder in serdeContext");
+                return toBase64(value);
             }
             return this.serdeContext?.base64Encoder(value);
         }
-        if (ns.isTimestampSchema() && value instanceof Date) {
-            const options = this.settings.timestampFormat;
-            const format = options.useTrait
-                ? ns.getSchema() === SCHEMA.TIMESTAMP_DEFAULT
-                    ? options.default
-                    : ns.getSchema() ?? options.default
-                : options.default;
+        if ((ns.isTimestampSchema() || ns.isDocumentSchema()) && value instanceof Date) {
+            const format = determineTimestampFormat(ns, this.settings);
             switch (format) {
-                case SCHEMA.TIMESTAMP_DATE_TIME:
+                case 5:
                     return value.toISOString().replace(".000Z", "Z");
-                case SCHEMA.TIMESTAMP_HTTP_DATE:
+                case 6:
                     return dateToUtcString(value);
-                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                case 7:
                     return value.getTime() / 1000;
                 default:
                     console.warn("Missing timestamp format, using epoch seconds", value);
@@ -94,11 +99,33 @@ export class JsonShapeSerializer extends SerdeContextConfig {
                 return String(value);
             }
         }
-        const mediaType = ns.getMergedTraits().mediaType;
-        if (ns.isStringSchema() && typeof value === "string" && mediaType) {
-            const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
-            if (isJson) {
-                return LazyJsonString.from(value);
+        if (ns.isStringSchema()) {
+            if (typeof value === "undefined" && ns.isIdempotencyToken()) {
+                return generateIdempotencyToken();
+            }
+            const mediaType = ns.getMergedTraits().mediaType;
+            if (value != null && mediaType) {
+                const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+                if (isJson) {
+                    return LazyJsonString.from(value);
+                }
+            }
+        }
+        if (ns.isDocumentSchema()) {
+            if (isObject) {
+                const out = Array.isArray(value) ? [] : {};
+                for (const [k, v] of Object.entries(value)) {
+                    if (v instanceof NumericValue) {
+                        out[k] = v;
+                    }
+                    else {
+                        out[k] = this._write(ns, v);
+                    }
+                }
+                return out;
+            }
+            else {
+                return structuredClone(value);
             }
         }
         return value;

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReplacer.js

@@ -14,7 +14,7 @@ export class JsonReplacer {
         this.stage = 1;
         return (key, value) => {
             if (value instanceof NumericValue) {
-                const v = `${NUMERIC_CONTROL_CHAR + +"nv" + this.counter++}_` + value.string;
+                const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string;
                 this.values.set(`"${v}"`, value.string);
                 return v;
             }