@mavogel/awscdk-rootmail 0.0.309 → 0.0.311

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

@@ -0,0 +1,279 @@
+import { XmlNode, XmlText } from "@aws-sdk/xml-builder";
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { NumericValue } from "@smithy/core/serde";
+import { dateToUtcString } from "@smithy/smithy-client";
+import { fromBase64, toBase64 } from "@smithy/util-base64";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+export class XmlShapeSerializer extends SerdeContextConfig {
+    settings;
+    stringBuffer;
+    byteBuffer;
+    buffer;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    write(schema, value) {
+        const ns = NormalizedSchema.of(schema);
+        if (ns.isStringSchema() && typeof value === "string") {
+            this.stringBuffer = value;
+        }
+        else if (ns.isBlobSchema()) {
+            this.byteBuffer =
+                "byteLength" in value
+                    ? value
+                    : (this.serdeContext?.base64Decoder ?? fromBase64)(value);
+        }
+        else {
+            this.buffer = this.writeStruct(ns, value, undefined);
+            const traits = ns.getMergedTraits();
+            if (traits.httpPayload && !traits.xmlName) {
+                this.buffer.withName(ns.getName());
+            }
+        }
+    }
+    flush() {
+        if (this.byteBuffer !== undefined) {
+            const bytes = this.byteBuffer;
+            delete this.byteBuffer;
+            return bytes;
+        }
+        if (this.stringBuffer !== undefined) {
+            const str = this.stringBuffer;
+            delete this.stringBuffer;
+            return str;
+        }
+        const buffer = this.buffer;
+        if (this.settings.xmlNamespace) {
+            if (!buffer?.attributes?.["xmlns"]) {
+                buffer.addAttribute("xmlns", this.settings.xmlNamespace);
+            }
+        }
+        delete this.buffer;
+        return buffer.toString();
+    }
+    writeStruct(ns, value, parentXmlns) {
+        const traits = ns.getMergedTraits();
+        const name = ns.isMemberSchema() && !traits.httpPayload
+            ? ns.getMemberTraits().xmlName ?? ns.getMemberName()
+            : traits.xmlName ?? ns.getName();
+        if (!name || !ns.isStructSchema()) {
+            throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write struct with empty name or non-struct, schema=${ns.getName(true)}.`);
+        }
+        const structXmlNode = XmlNode.of(name);
+        const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
+        if (xmlns) {
+            structXmlNode.addAttribute(xmlnsAttr, xmlns);
+        }
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+            const val = value[memberName];
+            if (val != null) {
+                if (memberSchema.getMergedTraits().xmlAttribute) {
+                    structXmlNode.addAttribute(memberSchema.getMergedTraits().xmlName ?? memberName, this.writeSimple(memberSchema, val));
+                    continue;
+                }
+                if (memberSchema.isListSchema()) {
+                    this.writeList(memberSchema, val, structXmlNode, xmlns);
+                }
+                else if (memberSchema.isMapSchema()) {
+                    this.writeMap(memberSchema, val, structXmlNode, xmlns);
+                }
+                else if (memberSchema.isStructSchema()) {
+                    structXmlNode.addChildNode(this.writeStruct(memberSchema, val, xmlns));
+                }
+                else {
+                    const memberNode = XmlNode.of(memberSchema.getMergedTraits().xmlName ?? memberSchema.getMemberName());
+                    this.writeSimpleInto(memberSchema, val, memberNode, xmlns);
+                    structXmlNode.addChildNode(memberNode);
+                }
+            }
+        }
+        return structXmlNode;
+    }
+    writeList(listMember, array, container, parentXmlns) {
+        if (!listMember.isMemberSchema()) {
+            throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member list: ${listMember.getName(true)}`);
+        }
+        const listTraits = listMember.getMergedTraits();
+        const listValueSchema = listMember.getValueSchema();
+        const listValueTraits = listValueSchema.getMergedTraits();
+        const sparse = !!listValueTraits.sparse;
+        const flat = !!listTraits.xmlFlattened;
+        const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(listMember, parentXmlns);
+        const writeItem = (container, value) => {
+            if (listValueSchema.isListSchema()) {
+                this.writeList(listValueSchema, Array.isArray(value) ? value : [value], container, xmlns);
+            }
+            else if (listValueSchema.isMapSchema()) {
+                this.writeMap(listValueSchema, value, container, xmlns);
+            }
+            else if (listValueSchema.isStructSchema()) {
+                const struct = this.writeStruct(listValueSchema, value, xmlns);
+                container.addChildNode(struct.withName(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member"));
+            }
+            else {
+                const listItemNode = XmlNode.of(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member");
+                this.writeSimpleInto(listValueSchema, value, listItemNode, xmlns);
+                container.addChildNode(listItemNode);
+            }
+        };
+        if (flat) {
+            for (const value of array) {
+                if (sparse || value != null) {
+                    writeItem(container, value);
+                }
+            }
+        }
+        else {
+            const listNode = XmlNode.of(listTraits.xmlName ?? listMember.getMemberName());
+            if (xmlns) {
+                listNode.addAttribute(xmlnsAttr, xmlns);
+            }
+            for (const value of array) {
+                if (sparse || value != null) {
+                    writeItem(listNode, value);
+                }
+            }
+            container.addChildNode(listNode);
+        }
+    }
+    writeMap(mapMember, map, container, parentXmlns, containerIsMap = false) {
+        if (!mapMember.isMemberSchema()) {
+            throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member map: ${mapMember.getName(true)}`);
+        }
+        const mapTraits = mapMember.getMergedTraits();
+        const mapKeySchema = mapMember.getKeySchema();
+        const mapKeyTraits = mapKeySchema.getMergedTraits();
+        const keyTag = mapKeyTraits.xmlName ?? "key";
+        const mapValueSchema = mapMember.getValueSchema();
+        const mapValueTraits = mapValueSchema.getMergedTraits();
+        const valueTag = mapValueTraits.xmlName ?? "value";
+        const sparse = !!mapValueTraits.sparse;
+        const flat = !!mapTraits.xmlFlattened;
+        const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(mapMember, parentXmlns);
+        const addKeyValue = (entry, key, val) => {
+            const keyNode = XmlNode.of(keyTag, key);
+            const [keyXmlnsAttr, keyXmlns] = this.getXmlnsAttribute(mapKeySchema, xmlns);
+            if (keyXmlns) {
+                keyNode.addAttribute(keyXmlnsAttr, keyXmlns);
+            }
+            entry.addChildNode(keyNode);
+            let valueNode = XmlNode.of(valueTag);
+            if (mapValueSchema.isListSchema()) {
+                this.writeList(mapValueSchema, val, valueNode, xmlns);
+            }
+            else if (mapValueSchema.isMapSchema()) {
+                this.writeMap(mapValueSchema, val, valueNode, xmlns, true);
+            }
+            else if (mapValueSchema.isStructSchema()) {
+                valueNode = this.writeStruct(mapValueSchema, val, xmlns);
+            }
+            else {
+                this.writeSimpleInto(mapValueSchema, val, valueNode, xmlns);
+            }
+            entry.addChildNode(valueNode);
+        };
+        if (flat) {
+            for (const [key, val] of Object.entries(map)) {
+                if (sparse || val != null) {
+                    const entry = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
+                    addKeyValue(entry, key, val);
+                    container.addChildNode(entry);
+                }
+            }
+        }
+        else {
+            let mapNode;
+            if (!containerIsMap) {
+                mapNode = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
+                if (xmlns) {
+                    mapNode.addAttribute(xmlnsAttr, xmlns);
+                }
+                container.addChildNode(mapNode);
+            }
+            for (const [key, val] of Object.entries(map)) {
+                if (sparse || val != null) {
+                    const entry = XmlNode.of("entry");
+                    addKeyValue(entry, key, val);
+                    (containerIsMap ? container : mapNode).addChildNode(entry);
+                }
+            }
+        }
+    }
+    writeSimple(_schema, value) {
+        if (null === value) {
+            throw new Error("@aws-sdk/core/protocols - (XML serializer) cannot write null value.");
+        }
+        const ns = NormalizedSchema.of(_schema);
+        let nodeContents = null;
+        if (value && typeof value === "object") {
+            if (ns.isBlobSchema()) {
+                nodeContents = (this.serdeContext?.base64Encoder ?? toBase64)(value);
+            }
+            else 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;
+                switch (format) {
+                    case SCHEMA.TIMESTAMP_DATE_TIME:
+                        nodeContents = value.toISOString().replace(".000Z", "Z");
+                        break;
+                    case SCHEMA.TIMESTAMP_HTTP_DATE:
+                        nodeContents = dateToUtcString(value);
+                        break;
+                    case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                        nodeContents = String(value.getTime() / 1000);
+                        break;
+                    default:
+                        console.warn("Missing timestamp format, using http date", value);
+                        nodeContents = dateToUtcString(value);
+                        break;
+                }
+            }
+            else if (ns.isBigDecimalSchema() && value) {
+                if (value instanceof NumericValue) {
+                    return value.string;
+                }
+                return String(value);
+            }
+            else if (ns.isMapSchema() || ns.isListSchema()) {
+                throw new Error("@aws-sdk/core/protocols - xml serializer, cannot call _write() on List/Map schema, call writeList or writeMap() instead.");
+            }
+            else {
+                throw new Error(`@aws-sdk/core/protocols - xml serializer, unhandled schema type for object value and schema: ${ns.getName(true)}`);
+            }
+        }
+        if (ns.isStringSchema() ||
+            ns.isBooleanSchema() ||
+            ns.isNumericSchema() ||
+            ns.isBigIntegerSchema() ||
+            ns.isBigDecimalSchema()) {
+            nodeContents = String(value);
+        }
+        if (nodeContents === null) {
+            throw new Error(`Unhandled schema-value pair ${ns.getName(true)}=${value}`);
+        }
+        return nodeContents;
+    }
+    writeSimpleInto(_schema, value, into, parentXmlns) {
+        const nodeContents = this.writeSimple(_schema, value);
+        const ns = NormalizedSchema.of(_schema);
+        const content = new XmlText(nodeContents);
+        const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
+        if (xmlns) {
+            into.addAttribute(xmlnsAttr, xmlns);
+        }
+        into.addChildNode(content);
+    }
+    getXmlnsAttribute(ns, parentXmlns) {
+        const traits = ns.getMergedTraits();
+        const [prefix, xmlns] = traits.xmlNamespace ?? [];
+        if (xmlns && xmlns !== parentXmlns) {
+            return [prefix ? `xmlns:${prefix}` : "xmlns", xmlns];
+        }
+        return [void 0, void 0];
+    }
+}

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

@@ -0,0 +1,27 @@
+export function simpleFormatXml(xml) {
+    let b = "";
+    let indentation = 0;
+    for (let i = 0; i < xml.length; ++i) {
+        const c = xml[i];
+        if (c === "<") {
+            if (xml[i + 1] === "/") {
+                b += "\n" + " ".repeat(indentation - 2) + c;
+                indentation -= 4;
+            }
+            else {
+                b += c;
+            }
+        }
+        else if (c === ">") {
+            indentation += 2;
+            b += c + "\n" + " ".repeat(indentation);
+        }
+        else {
+            b += c;
+        }
+    }
+    return b
+        .split("\n")
+        .filter((s) => !!s.trim())
+        .join("\n");
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/ConfigurableSerdeContext.d.ts

@@ -0,0 +1,8 @@
+import { ConfigurableSerdeContext, SerdeFunctions } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class SerdeContextConfig implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeFunctions;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/common.d.ts

@@ -1,2 +1,2 @@
-import type { SerdeContext } from "@smithy/types";
-export declare const collectBodyString: (streamBody: any, context: SerdeContext) => Promise<string>;
+import type { SerdeFunctions } from "@smithy/types";
+export declare const collectBodyString: (streamBody: any, context: SerdeFunctions) => Promise<string>;

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

@@ -1,4 +1,17 @@
 export * from "./coercing-serializers";
+export * from "./json/AwsJson1_0Protocol";
+export * from "./json/AwsJson1_1Protocol";
+export * from "./json/AwsJsonRpcProtocol";
+export * from "./json/AwsRestJsonProtocol";
+export * from "./json/JsonCodec";
+export * from "./json/JsonShapeDeserializer";
+export * from "./json/JsonShapeSerializer";
 export * from "./json/awsExpectUnion";
 export * from "./json/parseJsonBody";
+export * from "./query/AwsEc2QueryProtocol";
+export * from "./query/AwsQueryProtocol";
+export * from "./xml/AwsRestXmlProtocol";
+export * from "./xml/XmlCodec";
+export * from "./xml/XmlShapeDeserializer";
+export * from "./xml/XmlShapeSerializer";
 export * from "./xml/parseXmlBody";

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsJson1_0Protocol.d.ts

@@ -0,0 +1,12 @@
+import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
+/**
+ * @alpha
+ * @see https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html#differences-between-awsjson1-0-and-awsjson1-1
+ */
+export declare class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
+    constructor({ defaultNamespace }: {
+        defaultNamespace: string;
+    });
+    getShapeId(): string;
+    protected getJsonRpcVersion(): "1.0";
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsJson1_1Protocol.d.ts

@@ -0,0 +1,12 @@
+import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
+/**
+ * @alpha
+ * @see https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html#differences-between-awsjson1-0-and-awsjson1-1
+ */
+export declare class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
+    constructor({ defaultNamespace }: {
+        defaultNamespace: string;
+    });
+    getShapeId(): string;
+    protected getJsonRpcVersion(): "1.1";
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsJsonRpcProtocol.d.ts

@@ -0,0 +1,18 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest, HttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { JsonCodec } from "./JsonCodec";
+/**
+ * @alpha
+ */
+export declare abstract class AwsJsonRpcProtocol extends RpcProtocol {
+    protected serializer: ShapeSerializer<string | Uint8Array>;
+    protected deserializer: ShapeDeserializer<string | Uint8Array>;
+    private codec;
+    protected constructor({ defaultNamespace }: {
+        defaultNamespace: string;
+    });
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest>;
+    getPayloadCodec(): JsonCodec;
+    protected abstract getJsonRpcVersion(): "1.1" | "1.0";
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsRestJsonProtocol.d.ts

@@ -0,0 +1,19 @@
+import { HttpBindingProtocol } from "@smithy/core/protocols";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest, HttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { JsonCodec } from "./JsonCodec";
+/**
+ * @alpha
+ */
+export declare class AwsRestJsonProtocol extends HttpBindingProtocol {
+    protected serializer: ShapeSerializer<string | Uint8Array>;
+    protected deserializer: ShapeDeserializer<string | Uint8Array>;
+    private readonly codec;
+    constructor({ defaultNamespace }: {
+        defaultNamespace: string;
+    });
+    getShapeId(): string;
+    getPayloadCodec(): JsonCodec;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest>;
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/JsonCodec.d.ts

@@ -0,0 +1,19 @@
+import { Codec, CodecSettings } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { JsonShapeDeserializer } from "./JsonShapeDeserializer";
+import { JsonShapeSerializer } from "./JsonShapeSerializer";
+/**
+ * @alpha
+ */
+export type JsonSettings = CodecSettings & {
+    jsonName: boolean;
+};
+/**
+ * @public
+ */
+export declare class JsonCodec extends SerdeContextConfig implements Codec<string, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): JsonShapeSerializer;
+    createDeserializer(): JsonShapeDeserializer;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/JsonShapeDeserializer.d.ts

@@ -0,0 +1,13 @@
+import { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { JsonSettings } from "./JsonCodec";
+/**
+ * @alpha
+ */
+export declare class JsonShapeDeserializer extends SerdeContextConfig implements ShapeDeserializer<string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    read(schema: Schema, data: string | Uint8Array | unknown): Promise<any>;
+    readObject(schema: Schema, data: DocumentType): any;
+    private _read;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/JsonShapeSerializer.d.ts

@@ -0,0 +1,15 @@
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { JsonSettings } from "./JsonCodec";
+/**
+ * @alpha
+ */
+export declare class JsonShapeSerializer extends SerdeContextConfig implements ShapeSerializer<string> {
+    readonly settings: JsonSettings;
+    private buffer;
+    private rootSchema;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+    private _write;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/jsonReplacer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Serializes BigInt and NumericValue to JSON-number.
+ * @internal
+ */
+export declare class JsonReplacer {
+    /**
+     * Stores placeholder key to true serialized value lookup.
+     */
+    private readonly values;
+    private counter;
+    private stage;
+    /**
+     * Creates a jsonReplacer function that reserves big integer and big decimal values
+     * for later replacement.
+     */
+    createReplacer(): (key: string, value: unknown) => unknown;
+    /**
+     * Replaces placeholder keys with their true values.
+     */
+    replaceInJson(json: string): string;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/jsonReviver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param key - JSON object key.
+ * @param value - parsed value.
+ * @param context - original JSON string for reference. Not available until Node.js 21 and unavailable in Safari as
+ * of April 2025.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#browser_compatibility
+ *
+ * @alpha
+ *
+ * @returns transformed value.
+ */
+export declare function jsonReviver(key: string, value: any, context?: {
+    source?: string;
+}): any;

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/parseJsonBody.d.ts

@@ -1,12 +1,12 @@
-import type { HttpResponse, SerdeContext } from "@smithy/types";
+import type { HttpResponse, SerdeFunctions } from "@smithy/types";
 /**
  * @internal
  */
-export declare const parseJsonBody: (streamBody: any, context: SerdeContext) => any;
+export declare const parseJsonBody: (streamBody: any, context: SerdeFunctions) => any;
 /**
  * @internal
  */
-export declare const parseJsonErrorBody: (errorBody: any, context: SerdeContext) => Promise<any>;
+export declare const parseJsonErrorBody: (errorBody: any, context: SerdeFunctions) => Promise<any>;
 /**
  * @internal
  */

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/query/AwsEc2QueryProtocol.d.ts

@@ -0,0 +1,20 @@
+import { AwsQueryProtocol } from "./AwsQueryProtocol";
+/**
+ * @alpha
+ */
+export declare class AwsEc2QueryProtocol extends AwsQueryProtocol {
+    options: {
+        defaultNamespace: string;
+        xmlNamespace: string;
+        version: string;
+    };
+    constructor(options: {
+        defaultNamespace: string;
+        xmlNamespace: string;
+        version: string;
+    });
+    /**
+     * EC2 Query reads XResponse.XResult instead of XResponse directly.
+     */
+    protected useNestedResult(): boolean;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/query/AwsQueryProtocol.d.ts

@@ -0,0 +1,39 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { Codec, EndpointBearer, HandlerExecutionContext, HttpRequest, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import type { HttpResponse as IHttpResponse } from "@smithy/types/dist-types/http";
+import { XmlShapeDeserializer } from "../xml/XmlShapeDeserializer";
+import { QueryShapeSerializer } from "./QueryShapeSerializer";
+/**
+ * @alpha
+ */
+export declare class AwsQueryProtocol extends RpcProtocol {
+    options: {
+        defaultNamespace: string;
+        xmlNamespace: string;
+        version: string;
+    };
+    protected serializer: QueryShapeSerializer;
+    protected deserializer: XmlShapeDeserializer;
+    constructor(options: {
+        defaultNamespace: string;
+        xmlNamespace: string;
+        version: string;
+    });
+    getShapeId(): string;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    getPayloadCodec(): Codec<any, any>;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest>;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * EC2 Query overrides this.
+     */
+    protected useNestedResult(): boolean;
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    /**
+     * The variations in the error and error message locations are attributed to
+     * divergence between AWS Query and EC2 Query behavior.
+     */
+    protected loadQueryErrorCode(output: IHttpResponse, data: any): string | undefined;
+    protected loadQueryError(data: any): any | undefined;
+    protected loadQueryErrorMessage(data: any): string;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/query/QuerySerializerSettings.d.ts

@@ -0,0 +1,6 @@
+import { CodecSettings } from "@smithy/types";
+export type QuerySerializerSettings = CodecSettings & {
+    capitalizeKeys?: boolean;
+    flattenLists?: boolean;
+    serializeEmptyLists?: boolean;
+};

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/query/QueryShapeSerializer.d.ts

@@ -0,0 +1,16 @@
+import type { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import type { QuerySerializerSettings } from "./QuerySerializerSettings";
+/**
+ * @alpha
+ */
+export declare class QueryShapeSerializer extends SerdeContextConfig implements ShapeSerializer<string | Uint8Array> {
+    readonly settings: QuerySerializerSettings;
+    private buffer;
+    constructor(settings: QuerySerializerSettings);
+    write(schema: Schema, value: unknown, prefix?: string): void;
+    flush(): string | Uint8Array;
+    protected getKey(memberName: string, xmlName?: string): string;
+    protected writeKey(key: string): void;
+    protected writeValue(value: string): void;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/xml/AwsRestXmlProtocol.d.ts

@@ -0,0 +1,21 @@
+import { HttpBindingProtocol } from "@smithy/core/protocols";
+import { OperationSchema } from "@smithy/core/schema";
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { XmlCodec } from "./XmlCodec";
+/**
+ * @alpha
+ */
+export declare class AwsRestXmlProtocol extends HttpBindingProtocol {
+    private readonly codec;
+    protected serializer: ShapeSerializer<string | Uint8Array>;
+    protected deserializer: ShapeDeserializer<string | Uint8Array>;
+    constructor(options: {
+        defaultNamespace: string;
+        xmlNamespace: string;
+    });
+    getPayloadCodec(): XmlCodec;
+    getShapeId(): string;
+    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/core/dist-types/submodules/protocols/xml/XmlCodec.d.ts

@@ -0,0 +1,14 @@
+import { Codec, CodecSettings } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { XmlShapeDeserializer } from "./XmlShapeDeserializer";
+import { XmlShapeSerializer } from "./XmlShapeSerializer";
+export type XmlSettings = CodecSettings & {
+    xmlNamespace: string;
+    serviceNamespace: string;
+};
+export declare class XmlCodec extends SerdeContextConfig implements Codec<Uint8Array | string, Uint8Array | string> {
+    readonly settings: XmlSettings;
+    constructor(settings: XmlSettings);
+    createSerializer(): XmlShapeSerializer;
+    createDeserializer(): XmlShapeDeserializer;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/xml/XmlShapeDeserializer.d.ts

@@ -0,0 +1,20 @@
+import { Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../ConfigurableSerdeContext";
+import { XmlSettings } from "./XmlCodec";
+/**
+ * @alpha
+ */
+export declare class XmlShapeDeserializer extends SerdeContextConfig implements ShapeDeserializer<Uint8Array | string> {
+    readonly settings: XmlSettings;
+    private stringDeserializer;
+    constructor(settings: XmlSettings);
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    /**
+     * @param schema - describing the data.
+     * @param bytes - serialized data.
+     * @param key - used by AwsQuery to step one additional depth into the object before reading it.
+     */
+    read(schema: Schema, bytes: Uint8Array | string, key?: string): any;
+    readSchema(_schema: Schema, value: any): any;
+    protected parseXml(xml: string): any;
+}