@alliander-opensource/aws-jwt-sts 0.3.5 → 0.3.7

package/node_modules/@smithy/smithy-client/dist-cjs/index.js

@@ -1,746 +1,642 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Client: () => Client,
-  Command: () => Command,
-  NoOpLogger: () => NoOpLogger,
-  SENSITIVE_STRING: () => SENSITIVE_STRING,
-  ServiceException: () => ServiceException,
-  _json: () => _json,
-  collectBody: () => import_protocols.collectBody,
-  convertMap: () => convertMap,
-  createAggregatedClient: () => createAggregatedClient,
-  decorateServiceException: () => decorateServiceException,
-  emitWarningIfUnsupportedVersion: () => emitWarningIfUnsupportedVersion,
-  extendedEncodeURIComponent: () => import_protocols.extendedEncodeURIComponent,
-  getArrayIfSingleItem: () => getArrayIfSingleItem,
-  getDefaultClientConfiguration: () => getDefaultClientConfiguration,
-  getDefaultExtensionConfiguration: () => getDefaultExtensionConfiguration,
-  getValueFromTextNode: () => getValueFromTextNode,
-  isSerializableHeaderValue: () => isSerializableHeaderValue,
-  loadConfigsForDefaultMode: () => loadConfigsForDefaultMode,
-  map: () => map,
-  resolveDefaultRuntimeConfig: () => resolveDefaultRuntimeConfig,
-  resolvedPath: () => import_protocols.resolvedPath,
-  serializeDateTime: () => serializeDateTime,
-  serializeFloat: () => serializeFloat,
-  take: () => take,
-  throwDefaultError: () => throwDefaultError,
-  withBaseException: () => withBaseException
-});
-module.exports = __toCommonJS(src_exports);
+var middlewareStack = require('@smithy/middleware-stack');
+var types = require('@smithy/types');
+var schema = require('@smithy/core/schema');
+var serde = require('@smithy/core/serde');
+var protocols = require('@smithy/core/protocols');
 
-// src/client.ts
-var import_middleware_stack = require("@smithy/middleware-stack");
-var Client = class {
-  constructor(config) {
-    this.config = config;
-    this.middlewareStack = (0, import_middleware_stack.constructStack)();
-  }
-  static {
-    __name(this, "Client");
-  }
-  send(command, optionsOrCb, cb) {
-    const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
-    const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
-    const useHandlerCache = options === void 0 && this.config.cacheMiddleware === true;
-    let handler;
-    if (useHandlerCache) {
-      if (!this.handlers) {
-        this.handlers = /* @__PURE__ */ new WeakMap();
-      }
-      const handlers = this.handlers;
-      if (handlers.has(command.constructor)) {
-        handler = handlers.get(command.constructor);
-      } else {
-        handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
-        handlers.set(command.constructor, handler);
-      }
-    } else {
-      delete this.handlers;
-      handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
-    }
-    if (callback) {
-      handler(command).then(
-        (result) => callback(null, result.output),
-        (err) => callback(err)
-      ).catch(
-        // prevent any errors thrown in the callback from triggering an
-        // unhandled promise rejection
-        () => {
+class Client {
+    config;
+    middlewareStack = middlewareStack.constructStack();
+    initConfig;
+    handlers;
+    constructor(config) {
+        this.config = config;
+        const { protocol, protocolSettings } = config;
+        if (protocolSettings) {
+            if (typeof protocol === "function") {
+                config.protocol = new protocol(protocolSettings);
+            }
         }
-      );
-    } else {
-      return handler(command).then((result) => result.output);
-    }
-  }
-  destroy() {
-    this.config?.requestHandler?.destroy?.();
-    delete this.handlers;
-  }
-};
-
-// src/collect-stream-body.ts
-var import_protocols = require("@smithy/core/protocols");
+    }
+    send(command, optionsOrCb, cb) {
+        const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
+        const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
+        const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
+        let handler;
+        if (useHandlerCache) {
+            if (!this.handlers) {
+                this.handlers = new WeakMap();
+            }
+            const handlers = this.handlers;
+            if (handlers.has(command.constructor)) {
+                handler = handlers.get(command.constructor);
+            }
+            else {
+                handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+                handlers.set(command.constructor, handler);
+            }
+        }
+        else {
+            delete this.handlers;
+            handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+        }
+        if (callback) {
+            handler(command)
+                .then((result) => callback(null, result.output), (err) => callback(err))
+                .catch(() => { });
+        }
+        else {
+            return handler(command).then((result) => result.output);
+        }
+    }
+    destroy() {
+        this.config?.requestHandler?.destroy?.();
+        delete this.handlers;
+    }
+}
 
-// src/command.ts
+const SENSITIVE_STRING$1 = "***SensitiveInformation***";
+function schemaLogFilter(schema$1, data) {
+    if (data == null) {
+        return data;
+    }
+    const ns = schema.NormalizedSchema.of(schema$1);
+    if (ns.getMergedTraits().sensitive) {
+        return SENSITIVE_STRING$1;
+    }
+    if (ns.isListSchema()) {
+        const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
+        if (isSensitive) {
+            return SENSITIVE_STRING$1;
+        }
+    }
+    else if (ns.isMapSchema()) {
+        const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
+        if (isSensitive) {
+            return SENSITIVE_STRING$1;
+        }
+    }
+    else if (ns.isStructSchema() && typeof data === "object") {
+        const object = data;
+        const newObject = {};
+        for (const [member, memberNs] of ns.structIterator()) {
+            if (object[member] != null) {
+                newObject[member] = schemaLogFilter(memberNs, object[member]);
+            }
+        }
+        return newObject;
+    }
+    return data;
+}
 
-var import_types = require("@smithy/types");
-var Command = class {
-  constructor() {
-    this.middlewareStack = (0, import_middleware_stack.constructStack)();
-  }
-  static {
-    __name(this, "Command");
-  }
-  /**
-   * Factory for Command ClassBuilder.
-   * @internal
-   */
-  static classBuilder() {
-    return new ClassBuilder();
-  }
-  /**
-   * @internal
-   */
-  resolveMiddlewareWithContext(clientStack, configuration, options, {
-    middlewareFn,
-    clientName,
-    commandName,
-    inputFilterSensitiveLog,
-    outputFilterSensitiveLog,
-    smithyContext,
-    additionalContext,
-    CommandCtor
-  }) {
-    for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
-      this.middlewareStack.use(mw);
-    }
-    const stack = clientStack.concat(this.middlewareStack);
-    const { logger } = configuration;
-    const handlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog,
-      outputFilterSensitiveLog,
-      [import_types.SMITHY_CONTEXT_KEY]: {
-        commandInstance: this,
-        ...smithyContext
-      },
-      ...additionalContext
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request) => requestHandler.handle(request.request, options || {}),
-      handlerExecutionContext
-    );
-  }
-};
-var ClassBuilder = class {
-  constructor() {
-    this._init = () => {
-    };
-    this._ep = {};
-    this._middlewareFn = () => [];
-    this._commandName = "";
-    this._clientName = "";
-    this._additionalContext = {};
-    this._smithyContext = {};
-    this._inputFilterSensitiveLog = (_) => _;
-    this._outputFilterSensitiveLog = (_) => _;
-    this._serializer = null;
-    this._deserializer = null;
-  }
-  static {
-    __name(this, "ClassBuilder");
-  }
-  /**
-   * Optional init callback.
-   */
-  init(cb) {
-    this._init = cb;
-  }
-  /**
-   * Set the endpoint parameter instructions.
-   */
-  ep(endpointParameterInstructions) {
-    this._ep = endpointParameterInstructions;
-    return this;
-  }
-  /**
-   * Add any number of middleware.
-   */
-  m(middlewareSupplier) {
-    this._middlewareFn = middlewareSupplier;
-    return this;
-  }
-  /**
-   * Set the initial handler execution context Smithy field.
-   */
-  s(service, operation, smithyContext = {}) {
-    this._smithyContext = {
-      service,
-      operation,
-      ...smithyContext
-    };
-    return this;
-  }
-  /**
-   * Set the initial handler execution context.
-   */
-  c(additionalContext = {}) {
-    this._additionalContext = additionalContext;
-    return this;
-  }
-  /**
-   * Set constant string identifiers for the operation.
-   */
-  n(clientName, commandName) {
-    this._clientName = clientName;
-    this._commandName = commandName;
-    return this;
-  }
-  /**
-   * Set the input and output sensistive log filters.
-   */
-  f(inputFilter = (_) => _, outputFilter = (_) => _) {
-    this._inputFilterSensitiveLog = inputFilter;
-    this._outputFilterSensitiveLog = outputFilter;
-    return this;
-  }
-  /**
-   * Sets the serializer.
-   */
-  ser(serializer) {
-    this._serializer = serializer;
-    return this;
-  }
-  /**
-   * Sets the deserializer.
-   */
-  de(deserializer) {
-    this._deserializer = deserializer;
-    return this;
-  }
-  /**
-   * Sets input/output schema for the operation.
-   */
-  sc(operation) {
-    this._operationSchema = operation;
-    this._smithyContext.operationSchema = operation;
-    return this;
-  }
-  /**
-   * @returns a Command class with the classBuilder properties.
-   */
-  build() {
-    const closure = this;
-    let CommandRef;
-    return CommandRef = class extends Command {
-      /**
-       * @public
-       */
-      constructor(...[input]) {
-        super();
-        /**
-         * @internal
-         */
-        // @ts-ignore used in middlewareFn closure.
-        this.serialize = closure._serializer;
-        /**
-         * @internal
-         */
-        // @ts-ignore used in middlewareFn closure.
-        this.deserialize = closure._deserializer;
-        this.input = input ?? {};
-        closure._init(this);
-        this.schema = closure._operationSchema;
-      }
-      static {
-        __name(this, "CommandRef");
-      }
-      /**
-       * @public
-       */
-      static getEndpointParameterInstructions() {
-        return closure._ep;
-      }
-      /**
-       * @internal
-       */
-      resolveMiddleware(stack, configuration, options) {
-        return this.resolveMiddlewareWithContext(stack, configuration, options, {
-          CommandCtor: CommandRef,
-          middlewareFn: closure._middlewareFn,
-          clientName: closure._clientName,
-          commandName: closure._commandName,
-          inputFilterSensitiveLog: closure._inputFilterSensitiveLog,
-          outputFilterSensitiveLog: closure._outputFilterSensitiveLog,
-          smithyContext: closure._smithyContext,
-          additionalContext: closure._additionalContext
+class Command {
+    middlewareStack = middlewareStack.constructStack();
+    schema;
+    static classBuilder() {
+        return new ClassBuilder();
+    }
+    resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }) {
+        for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
+            this.middlewareStack.use(mw);
+        }
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog,
+            outputFilterSensitiveLog,
+            [types.SMITHY_CONTEXT_KEY]: {
+                commandInstance: this,
+                ...smithyContext,
+            },
+            ...additionalContext,
+        };
+        const { requestHandler } = configuration;
+        let requestOptions = options ?? {};
+        if (smithyContext.eventStream) {
+            requestOptions = {
+                isEventStream: true,
+                ...requestOptions,
+            };
+        }
+        return stack.resolve((request) => requestHandler.handle(request.request, requestOptions), handlerExecutionContext);
+    }
+}
+class ClassBuilder {
+    _init = () => { };
+    _ep = {};
+    _middlewareFn = () => [];
+    _commandName = "";
+    _clientName = "";
+    _additionalContext = {};
+    _smithyContext = {};
+    _inputFilterSensitiveLog = undefined;
+    _outputFilterSensitiveLog = undefined;
+    _serializer = null;
+    _deserializer = null;
+    _operationSchema;
+    init(cb) {
+        this._init = cb;
+    }
+    ep(endpointParameterInstructions) {
+        this._ep = endpointParameterInstructions;
+        return this;
+    }
+    m(middlewareSupplier) {
+        this._middlewareFn = middlewareSupplier;
+        return this;
+    }
+    s(service, operation, smithyContext = {}) {
+        this._smithyContext = {
+            service,
+            operation,
+            ...smithyContext,
+        };
+        return this;
+    }
+    c(additionalContext = {}) {
+        this._additionalContext = additionalContext;
+        return this;
+    }
+    n(clientName, commandName) {
+        this._clientName = clientName;
+        this._commandName = commandName;
+        return this;
+    }
+    f(inputFilter = (_) => _, outputFilter = (_) => _) {
+        this._inputFilterSensitiveLog = inputFilter;
+        this._outputFilterSensitiveLog = outputFilter;
+        return this;
+    }
+    ser(serializer) {
+        this._serializer = serializer;
+        return this;
+    }
+    de(deserializer) {
+        this._deserializer = deserializer;
+        return this;
+    }
+    sc(operation) {
+        this._operationSchema = operation;
+        this._smithyContext.operationSchema = operation;
+        return this;
+    }
+    build() {
+        const closure = this;
+        let CommandRef;
+        return (CommandRef = class extends Command {
+            input;
+            static getEndpointParameterInstructions() {
+                return closure._ep;
+            }
+            constructor(...[input]) {
+                super();
+                this.input = input ?? {};
+                closure._init(this);
+                this.schema = closure._operationSchema;
+            }
+            resolveMiddleware(stack, configuration, options) {
+                const op = closure._operationSchema;
+                const input = op?.[4] ?? op?.input;
+                const output = op?.[5] ?? op?.output;
+                return this.resolveMiddlewareWithContext(stack, configuration, options, {
+                    CommandCtor: CommandRef,
+                    middlewareFn: closure._middlewareFn,
+                    clientName: closure._clientName,
+                    commandName: closure._commandName,
+                    inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
+                    outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
+                    smithyContext: closure._smithyContext,
+                    additionalContext: closure._additionalContext,
+                });
+            }
+            serialize = closure._serializer;
+            deserialize = closure._deserializer;
         });
-      }
-    };
-  }
-};
-
-// src/constants.ts
-var SENSITIVE_STRING = "***SensitiveInformation***";
+    }
+}
 
-// src/create-aggregated-client.ts
-var createAggregatedClient = /* @__PURE__ */ __name((commands, Client2) => {
-  for (const command of Object.keys(commands)) {
-    const CommandCtor = commands[command];
-    const methodImpl = /* @__PURE__ */ __name(async function(args, optionsOrCb, cb) {
-      const command2 = new CommandCtor(args);
-      if (typeof optionsOrCb === "function") {
-        this.send(command2, optionsOrCb);
-      } else if (typeof cb === "function") {
-        if (typeof optionsOrCb !== "object")
-          throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
-        this.send(command2, optionsOrCb || {}, cb);
-      } else {
-        return this.send(command2, optionsOrCb);
-      }
-    }, "methodImpl");
-    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
-    Client2.prototype[methodName] = methodImpl;
-  }
-}, "createAggregatedClient");
+const SENSITIVE_STRING = "***SensitiveInformation***";
 
-// src/exceptions.ts
-var ServiceException = class _ServiceException extends Error {
-  static {
-    __name(this, "ServiceException");
-  }
-  constructor(options) {
-    super(options.message);
-    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
-    this.name = options.name;
-    this.$fault = options.$fault;
-    this.$metadata = options.$metadata;
-  }
-  /**
-   * Checks if a value is an instance of ServiceException (duck typed)
-   */
-  static isInstance(value) {
-    if (!value)
-      return false;
-    const candidate = value;
-    return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
-  }
-  /**
-   * Custom instanceof check to support the operator for ServiceException base class
-   */
-  static [Symbol.hasInstance](instance) {
-    if (!instance)
-      return false;
-    const candidate = instance;
-    if (this === _ServiceException) {
-      return _ServiceException.isInstance(instance);
-    }
-    if (_ServiceException.isInstance(instance)) {
-      if (candidate.name && this.name) {
-        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
-      }
-      return this.prototype.isPrototypeOf(instance);
-    }
-    return false;
-  }
+const createAggregatedClient = (commands, Client, options) => {
+    for (const [command, CommandCtor] of Object.entries(commands)) {
+        const methodImpl = async function (args, optionsOrCb, cb) {
+            const command = new CommandCtor(args);
+            if (typeof optionsOrCb === "function") {
+                this.send(command, optionsOrCb);
+            }
+            else if (typeof cb === "function") {
+                if (typeof optionsOrCb !== "object")
+                    throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
+                this.send(command, optionsOrCb || {}, cb);
+            }
+            else {
+                return this.send(command, optionsOrCb);
+            }
+        };
+        const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
+        Client.prototype[methodName] = methodImpl;
+    }
+    const { paginators = {}, waiters = {} } = options ?? {};
+    for (const [paginatorName, paginatorFn] of Object.entries(paginators)) {
+        if (Client.prototype[paginatorName] === void 0) {
+            Client.prototype[paginatorName] = function (commandInput = {}, paginationConfiguration, ...rest) {
+                return paginatorFn({
+                    ...paginationConfiguration,
+                    client: this,
+                }, commandInput, ...rest);
+            };
+        }
+    }
+    for (const [waiterName, waiterFn] of Object.entries(waiters)) {
+        if (Client.prototype[waiterName] === void 0) {
+            Client.prototype[waiterName] = async function (commandInput = {}, waiterConfiguration, ...rest) {
+                let config = waiterConfiguration;
+                if (typeof waiterConfiguration === "number") {
+                    config = {
+                        maxWaitTime: waiterConfiguration,
+                    };
+                }
+                return waiterFn({
+                    ...config,
+                    client: this,
+                }, commandInput, ...rest);
+            };
+        }
+    }
 };
-var decorateServiceException = /* @__PURE__ */ __name((exception, additions = {}) => {
-  Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
-    if (exception[k] == void 0 || exception[k] === "") {
-      exception[k] = v;
-    }
-  });
-  const message = exception.message || exception.Message || "UnknownError";
-  exception.message = message;
-  delete exception.Message;
-  return exception;
-}, "decorateServiceException");
-
-// src/default-error-handler.ts
-var throwDefaultError = /* @__PURE__ */ __name(({ output, parsedBody, exceptionCtor, errorCode }) => {
-  const $metadata = deserializeMetadata(output);
-  const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : void 0;
-  const response = new exceptionCtor({
-    name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
-    $fault: "client",
-    $metadata
-  });
-  throw decorateServiceException(response, parsedBody);
-}, "throwDefaultError");
-var withBaseException = /* @__PURE__ */ __name((ExceptionCtor) => {
-  return ({ output, parsedBody, errorCode }) => {
-    throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
-  };
-}, "withBaseException");
-var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
-  httpStatusCode: output.statusCode,
-  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-  extendedRequestId: output.headers["x-amz-id-2"],
-  cfId: output.headers["x-amz-cf-id"]
-}), "deserializeMetadata");
 
-// src/defaults-mode.ts
-var loadConfigsForDefaultMode = /* @__PURE__ */ __name((mode) => {
-  switch (mode) {
-    case "standard":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3100
-      };
-    case "in-region":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 1100
-      };
-    case "cross-region":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3100
-      };
-    case "mobile":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3e4
-      };
-    default:
-      return {};
-  }
-}, "loadConfigsForDefaultMode");
-
-// src/emitWarningIfUnsupportedVersion.ts
-var warningEmitted = false;
-var emitWarningIfUnsupportedVersion = /* @__PURE__ */ __name((version) => {
-  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
-    warningEmitted = true;
-  }
-}, "emitWarningIfUnsupportedVersion");
+class ServiceException extends Error {
+    $fault;
+    $response;
+    $retryable;
+    $metadata;
+    constructor(options) {
+        super(options.message);
+        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
+        this.name = options.name;
+        this.$fault = options.$fault;
+        this.$metadata = options.$metadata;
+    }
+    static isInstance(value) {
+        if (!value)
+            return false;
+        const candidate = value;
+        return (ServiceException.prototype.isPrototypeOf(candidate) ||
+            (Boolean(candidate.$fault) &&
+                Boolean(candidate.$metadata) &&
+                (candidate.$fault === "client" || candidate.$fault === "server")));
+    }
+    static [Symbol.hasInstance](instance) {
+        if (!instance)
+            return false;
+        const candidate = instance;
+        if (this === ServiceException) {
+            return ServiceException.isInstance(instance);
+        }
+        if (ServiceException.isInstance(instance)) {
+            if (candidate.name && this.name) {
+                return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
+            }
+            return this.prototype.isPrototypeOf(instance);
+        }
+        return false;
+    }
+}
+const decorateServiceException = (exception, additions = {}) => {
+    Object.entries(additions)
+        .filter(([, v]) => v !== undefined)
+        .forEach(([k, v]) => {
+        if (exception[k] == undefined || exception[k] === "") {
+            exception[k] = v;
+        }
+    });
+    const message = exception.message || exception.Message || "UnknownError";
+    exception.message = message;
+    delete exception.Message;
+    return exception;
+};
 
-// src/extended-encode-uri-component.ts
+const throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
+    const $metadata = deserializeMetadata(output);
+    const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+    const response = new exceptionCtor({
+        name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
+        $fault: "client",
+        $metadata,
+    });
+    throw decorateServiceException(response, parsedBody);
+};
+const withBaseException = (ExceptionCtor) => {
+    return ({ output, parsedBody, errorCode }) => {
+        throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
+    };
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
 
+const loadConfigsForDefaultMode = (mode) => {
+    switch (mode) {
+        case "standard":
+            return {
+                retryMode: "standard",
+                connectionTimeout: 3100,
+            };
+        case "in-region":
+            return {
+                retryMode: "standard",
+                connectionTimeout: 1100,
+            };
+        case "cross-region":
+            return {
+                retryMode: "standard",
+                connectionTimeout: 3100,
+            };
+        case "mobile":
+            return {
+                retryMode: "standard",
+                connectionTimeout: 30000,
+            };
+        default:
+            return {};
+    }
+};
 
-// src/extensions/checksum.ts
+let warningEmitted = false;
+const emitWarningIfUnsupportedVersion = (version) => {
+    if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+        warningEmitted = true;
+    }
+};
 
-var getChecksumConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const checksumAlgorithms = [];
-  for (const id in import_types.AlgorithmId) {
-    const algorithmId = import_types.AlgorithmId[id];
-    if (runtimeConfig[algorithmId] === void 0) {
-      continue;
-    }
-    checksumAlgorithms.push({
-      algorithmId: () => algorithmId,
-      checksumConstructor: () => runtimeConfig[algorithmId]
+const knownAlgorithms = Object.values(types.AlgorithmId);
+const getChecksumConfiguration = (runtimeConfig) => {
+    const checksumAlgorithms = [];
+    for (const id in types.AlgorithmId) {
+        const algorithmId = types.AlgorithmId[id];
+        if (runtimeConfig[algorithmId] === undefined) {
+            continue;
+        }
+        checksumAlgorithms.push({
+            algorithmId: () => algorithmId,
+            checksumConstructor: () => runtimeConfig[algorithmId],
+        });
+    }
+    for (const [id, ChecksumCtor] of Object.entries(runtimeConfig.checksumAlgorithms ?? {})) {
+        checksumAlgorithms.push({
+            algorithmId: () => id,
+            checksumConstructor: () => ChecksumCtor,
+        });
+    }
+    return {
+        addChecksumAlgorithm(algo) {
+            runtimeConfig.checksumAlgorithms = runtimeConfig.checksumAlgorithms ?? {};
+            const id = algo.algorithmId();
+            const ctor = algo.checksumConstructor();
+            if (knownAlgorithms.includes(id)) {
+                runtimeConfig.checksumAlgorithms[id.toUpperCase()] = ctor;
+            }
+            else {
+                runtimeConfig.checksumAlgorithms[id] = ctor;
+            }
+            checksumAlgorithms.push(algo);
+        },
+        checksumAlgorithms() {
+            return checksumAlgorithms;
+        },
+    };
+};
+const resolveChecksumRuntimeConfig = (clientConfig) => {
+    const runtimeConfig = {};
+    clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+        const id = checksumAlgorithm.algorithmId();
+        if (knownAlgorithms.includes(id)) {
+            runtimeConfig[id] = checksumAlgorithm.checksumConstructor();
+        }
     });
-  }
-  return {
-    addChecksumAlgorithm(algo) {
-      checksumAlgorithms.push(algo);
-    },
-    checksumAlgorithms() {
-      return checksumAlgorithms;
-    }
-  };
-}, "getChecksumConfiguration");
-var resolveChecksumRuntimeConfig = /* @__PURE__ */ __name((clientConfig) => {
-  const runtimeConfig = {};
-  clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
-    runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
-  });
-  return runtimeConfig;
-}, "resolveChecksumRuntimeConfig");
-
-// src/extensions/retry.ts
-var getRetryConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  return {
-    setRetryStrategy(retryStrategy) {
-      runtimeConfig.retryStrategy = retryStrategy;
-    },
-    retryStrategy() {
-      return runtimeConfig.retryStrategy;
-    }
-  };
-}, "getRetryConfiguration");
-var resolveRetryRuntimeConfig = /* @__PURE__ */ __name((retryStrategyConfiguration) => {
-  const runtimeConfig = {};
-  runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
-  return runtimeConfig;
-}, "resolveRetryRuntimeConfig");
+    return runtimeConfig;
+};
 
-// src/extensions/defaultExtensionConfiguration.ts
-var getDefaultExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
-}, "getDefaultExtensionConfiguration");
-var getDefaultClientConfiguration = getDefaultExtensionConfiguration;
-var resolveDefaultRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
-}, "resolveDefaultRuntimeConfig");
+const getRetryConfiguration = (runtimeConfig) => {
+    return {
+        setRetryStrategy(retryStrategy) {
+            runtimeConfig.retryStrategy = retryStrategy;
+        },
+        retryStrategy() {
+            return runtimeConfig.retryStrategy;
+        },
+    };
+};
+const resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
+    const runtimeConfig = {};
+    runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
+    return runtimeConfig;
+};
 
-// src/get-array-if-single-item.ts
-var getArrayIfSingleItem = /* @__PURE__ */ __name((mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray], "getArrayIfSingleItem");
+const getDefaultExtensionConfiguration = (runtimeConfig) => {
+    return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
+};
+const getDefaultClientConfiguration = getDefaultExtensionConfiguration;
+const resolveDefaultRuntimeConfig = (config) => {
+    return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
+};
 
-// src/get-value-from-text-node.ts
-var getValueFromTextNode = /* @__PURE__ */ __name((obj) => {
-  const textNodeName = "#text";
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== void 0) {
-      obj[key] = obj[key][textNodeName];
-    } else if (typeof obj[key] === "object" && obj[key] !== null) {
-      obj[key] = getValueFromTextNode(obj[key]);
-    }
-  }
-  return obj;
-}, "getValueFromTextNode");
+const getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray];
 
-// src/is-serializable-header-value.ts
-var isSerializableHeaderValue = /* @__PURE__ */ __name((value) => {
-  return value != null;
-}, "isSerializableHeaderValue");
+const getValueFromTextNode = (obj) => {
+    const textNodeName = "#text";
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) {
+            obj[key] = obj[key][textNodeName];
+        }
+        else if (typeof obj[key] === "object" && obj[key] !== null) {
+            obj[key] = getValueFromTextNode(obj[key]);
+        }
+    }
+    return obj;
+};
 
-// src/NoOpLogger.ts
-var NoOpLogger = class {
-  static {
-    __name(this, "NoOpLogger");
-  }
-  trace() {
-  }
-  debug() {
-  }
-  info() {
-  }
-  warn() {
-  }
-  error() {
-  }
+const isSerializableHeaderValue = (value) => {
+    return value != null;
 };
 
-// src/object-mapping.ts
+class NoOpLogger {
+    trace() { }
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+}
+
 function map(arg0, arg1, arg2) {
-  let target;
-  let filter;
-  let instructions;
-  if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
-    target = {};
-    instructions = arg0;
-  } else {
-    target = arg0;
-    if (typeof arg1 === "function") {
-      filter = arg1;
-      instructions = arg2;
-      return mapWithFilter(target, filter, instructions);
-    } else {
-      instructions = arg1;
-    }
-  }
-  for (const key of Object.keys(instructions)) {
-    if (!Array.isArray(instructions[key])) {
-      target[key] = instructions[key];
-      continue;
-    }
-    applyInstruction(target, null, instructions, key);
-  }
-  return target;
+    let target;
+    let filter;
+    let instructions;
+    if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
+        target = {};
+        instructions = arg0;
+    }
+    else {
+        target = arg0;
+        if (typeof arg1 === "function") {
+            filter = arg1;
+            instructions = arg2;
+            return mapWithFilter(target, filter, instructions);
+        }
+        else {
+            instructions = arg1;
+        }
+    }
+    for (const key of Object.keys(instructions)) {
+        if (!Array.isArray(instructions[key])) {
+            target[key] = instructions[key];
+            continue;
+        }
+        applyInstruction(target, null, instructions, key);
+    }
+    return target;
 }
-__name(map, "map");
-var convertMap = /* @__PURE__ */ __name((target) => {
-  const output = {};
-  for (const [k, v] of Object.entries(target || {})) {
-    output[k] = [, v];
-  }
-  return output;
-}, "convertMap");
-var take = /* @__PURE__ */ __name((source, instructions) => {
-  const out = {};
-  for (const key in instructions) {
-    applyInstruction(out, source, instructions, key);
-  }
-  return out;
-}, "take");
-var mapWithFilter = /* @__PURE__ */ __name((target, filter, instructions) => {
-  return map(
-    target,
-    Object.entries(instructions).reduce(
-      (_instructions, [key, value]) => {
+const convertMap = (target) => {
+    const output = {};
+    for (const [k, v] of Object.entries(target || {})) {
+        output[k] = [, v];
+    }
+    return output;
+};
+const take = (source, instructions) => {
+    const out = {};
+    for (const key in instructions) {
+        applyInstruction(out, source, instructions, key);
+    }
+    return out;
+};
+const mapWithFilter = (target, filter, instructions) => {
+    return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
         if (Array.isArray(value)) {
-          _instructions[key] = value;
-        } else {
-          if (typeof value === "function") {
-            _instructions[key] = [filter, value()];
-          } else {
-            _instructions[key] = [filter, value];
-          }
+            _instructions[key] = value;
+        }
+        else {
+            if (typeof value === "function") {
+                _instructions[key] = [filter, value()];
+            }
+            else {
+                _instructions[key] = [filter, value];
+            }
         }
         return _instructions;
-      },
-      {}
-    )
-  );
-}, "mapWithFilter");
-var applyInstruction = /* @__PURE__ */ __name((target, source, instructions, targetKey) => {
-  if (source !== null) {
-    let instruction = instructions[targetKey];
-    if (typeof instruction === "function") {
-      instruction = [, instruction];
-    }
-    const [filter2 = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
-    if (typeof filter2 === "function" && filter2(source[sourceKey]) || typeof filter2 !== "function" && !!filter2) {
-      target[targetKey] = valueFn(source[sourceKey]);
-    }
-    return;
-  }
-  let [filter, value] = instructions[targetKey];
-  if (typeof value === "function") {
-    let _value;
-    const defaultFilterPassed = filter === void 0 && (_value = value()) != null;
-    const customFilterPassed = typeof filter === "function" && !!filter(void 0) || typeof filter !== "function" && !!filter;
-    if (defaultFilterPassed) {
-      target[targetKey] = _value;
-    } else if (customFilterPassed) {
-      target[targetKey] = value();
-    }
-  } else {
-    const defaultFilterPassed = filter === void 0 && value != null;
-    const customFilterPassed = typeof filter === "function" && !!filter(value) || typeof filter !== "function" && !!filter;
-    if (defaultFilterPassed || customFilterPassed) {
-      target[targetKey] = value;
-    }
-  }
-}, "applyInstruction");
-var nonNullish = /* @__PURE__ */ __name((_) => _ != null, "nonNullish");
-var pass = /* @__PURE__ */ __name((_) => _, "pass");
-
-// src/resolve-path.ts
-
+    }, {}));
+};
+const applyInstruction = (target, source, instructions, targetKey) => {
+    if (source !== null) {
+        let instruction = instructions[targetKey];
+        if (typeof instruction === "function") {
+            instruction = [, instruction];
+        }
+        const [filter = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
+        if ((typeof filter === "function" && filter(source[sourceKey])) || (typeof filter !== "function" && !!filter)) {
+            target[targetKey] = valueFn(source[sourceKey]);
+        }
+        return;
+    }
+    let [filter, value] = instructions[targetKey];
+    if (typeof value === "function") {
+        let _value;
+        const defaultFilterPassed = filter === undefined && (_value = value()) != null;
+        const customFilterPassed = (typeof filter === "function" && !!filter(void 0)) || (typeof filter !== "function" && !!filter);
+        if (defaultFilterPassed) {
+            target[targetKey] = _value;
+        }
+        else if (customFilterPassed) {
+            target[targetKey] = value();
+        }
+    }
+    else {
+        const defaultFilterPassed = filter === undefined && value != null;
+        const customFilterPassed = (typeof filter === "function" && !!filter(value)) || (typeof filter !== "function" && !!filter);
+        if (defaultFilterPassed || customFilterPassed) {
+            target[targetKey] = value;
+        }
+    }
+};
+const nonNullish = (_) => _ != null;
+const pass = (_) => _;
 
-// src/ser-utils.ts
-var serializeFloat = /* @__PURE__ */ __name((value) => {
-  if (value !== value) {
-    return "NaN";
-  }
-  switch (value) {
-    case Infinity:
-      return "Infinity";
-    case -Infinity:
-      return "-Infinity";
-    default:
-      return value;
-  }
-}, "serializeFloat");
-var serializeDateTime = /* @__PURE__ */ __name((date) => date.toISOString().replace(".000Z", "Z"), "serializeDateTime");
+const serializeFloat = (value) => {
+    if (value !== value) {
+        return "NaN";
+    }
+    switch (value) {
+        case Infinity:
+            return "Infinity";
+        case -Infinity:
+            return "-Infinity";
+        default:
+            return value;
+    }
+};
+const serializeDateTime = (date) => date.toISOString().replace(".000Z", "Z");
 
-// src/serde-json.ts
-var _json = /* @__PURE__ */ __name((obj) => {
-  if (obj == null) {
-    return {};
-  }
-  if (Array.isArray(obj)) {
-    return obj.filter((_) => _ != null).map(_json);
-  }
-  if (typeof obj === "object") {
-    const target = {};
-    for (const key of Object.keys(obj)) {
-      if (obj[key] == null) {
-        continue;
-      }
-      target[key] = _json(obj[key]);
+const _json = (obj) => {
+    if (obj == null) {
+        return {};
     }
-    return target;
-  }
-  return obj;
-}, "_json");
+    if (Array.isArray(obj)) {
+        return obj.filter((_) => _ != null).map(_json);
+    }
+    if (typeof obj === "object") {
+        const target = {};
+        for (const key of Object.keys(obj)) {
+            if (obj[key] == null) {
+                continue;
+            }
+            target[key] = _json(obj[key]);
+        }
+        return target;
+    }
+    return obj;
+};
 
-// src/index.ts
-__reExport(src_exports, require("@smithy/core/serde"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
+exports.collectBody = protocols.collectBody;
+exports.extendedEncodeURIComponent = protocols.extendedEncodeURIComponent;
+exports.resolvedPath = protocols.resolvedPath;
+exports.Client = Client;
+exports.Command = Command;
+exports.NoOpLogger = NoOpLogger;
+exports.SENSITIVE_STRING = SENSITIVE_STRING;
+exports.ServiceException = ServiceException;
+exports._json = _json;
+exports.convertMap = convertMap;
+exports.createAggregatedClient = createAggregatedClient;
+exports.decorateServiceException = decorateServiceException;
+exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
+exports.getArrayIfSingleItem = getArrayIfSingleItem;
+exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
+exports.getDefaultExtensionConfiguration = getDefaultExtensionConfiguration;
+exports.getValueFromTextNode = getValueFromTextNode;
+exports.isSerializableHeaderValue = isSerializableHeaderValue;
+exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode;
+exports.map = map;
+exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
+exports.serializeDateTime = serializeDateTime;
+exports.serializeFloat = serializeFloat;
+exports.take = take;
+exports.throwDefaultError = throwDefaultError;
+exports.withBaseException = withBaseException;
+Object.prototype.hasOwnProperty.call(serde, '__proto__') &&
+    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+    Object.defineProperty(exports, '__proto__', {
+        enumerable: true,
+        value: serde['__proto__']
+    });
 
-0 && (module.exports = {
-  Client,
-  collectBody,
-  Command,
-  SENSITIVE_STRING,
-  createAggregatedClient,
-  throwDefaultError,
-  withBaseException,
-  loadConfigsForDefaultMode,
-  emitWarningIfUnsupportedVersion,
-  ServiceException,
-  decorateServiceException,
-  extendedEncodeURIComponent,
-  getDefaultExtensionConfiguration,
-  getDefaultClientConfiguration,
-  resolveDefaultRuntimeConfig,
-  getArrayIfSingleItem,
-  getValueFromTextNode,
-  isSerializableHeaderValue,
-  NoOpLogger,
-  convertMap,
-  take,
-  map,
-  resolvedPath,
-  serializeFloat,
-  serializeDateTime,
-  _json,
-  LazyJsonString,
-  NumericValue,
-  copyDocumentWithTransform,
-  dateToUtcString,
-  expectBoolean,
-  expectByte,
-  expectFloat32,
-  expectInt,
-  expectInt32,
-  expectLong,
-  expectNonNull,
-  expectNumber,
-  expectObject,
-  expectShort,
-  expectString,
-  expectUnion,
-  handleFloat,
-  limitedParseDouble,
-  limitedParseFloat,
-  limitedParseFloat32,
-  logger,
-  nv,
-  parseBoolean,
-  parseEpochTimestamp,
-  parseRfc3339DateTime,
-  parseRfc3339DateTimeWithOffset,
-  parseRfc7231DateTime,
-  quoteHeader,
-  splitEvery,
-  splitHeader,
-  strictParseByte,
-  strictParseDouble,
-  strictParseFloat,
-  strictParseFloat32,
-  strictParseInt,
-  strictParseInt32,
-  strictParseLong,
-  strictParseShort
+Object.keys(serde).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = serde[k];
 });
-