thinkwork-cli 0.13.1 → 0.13.2

package/dist/chunk-DVPBI5HM.js

@@ -0,0 +1,1728 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  SignatureV4
+} from "./chunk-EI5ZX7CN.js";
+import {
+  decorateServiceException,
+  doesIdentityRequireRefresh,
+  getValueFromTextNode,
+  isIdentityExpired,
+  memoizeIdentityProvider,
+  normalizeProvider,
+  setCredentialFeature
+} from "./chunk-QOERT44A.js";
+import {
+  FromStringShapeDeserializer,
+  HttpBindingProtocol,
+  HttpInterceptingShapeDeserializer,
+  HttpInterceptingShapeSerializer,
+  HttpRequest,
+  HttpResponse,
+  NormalizedSchema,
+  ProviderError,
+  RpcProtocol,
+  TypeRegistry,
+  collectBody,
+  deref,
+  determineTimestampFormat,
+  extendedEncodeURIComponent
+} from "./chunk-XYM7PE2A.js";
+import {
+  LazyJsonString,
+  NumericValue,
+  dateToUtcString,
+  fromBase64,
+  generateIdempotencyToken,
+  parseEpochTimestamp,
+  parseRfc3339DateTimeWithOffset,
+  parseRfc7231DateTime,
+  toBase64,
+  toUtf8
+} from "./chunk-OCPHU34C.js";
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js
+var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0;
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js
+var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js
+var isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5;
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js
+var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
+  const clockTimeInMs = Date.parse(clockTime);
+  if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
+    return clockTimeInMs - Date.now();
+  }
+  return currentSystemClockOffset;
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js
+var throwSigningPropertyError = (name, property) => {
+  if (!property) {
+    throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
+  }
+  return property;
+};
+var validateSigningProperties = async (signingProperties) => {
+  const context = throwSigningPropertyError("context", signingProperties.context);
+  const config = throwSigningPropertyError("config", signingProperties.config);
+  const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+  const signerFunction = throwSigningPropertyError("signer", config.signer);
+  const signer = await signerFunction(authScheme);
+  const signingRegion = signingProperties?.signingRegion;
+  const signingRegionSet = signingProperties?.signingRegionSet;
+  const signingName = signingProperties?.signingName;
+  return {
+    config,
+    signer,
+    signingRegion,
+    signingRegionSet,
+    signingName
+  };
+};
+var AwsSdkSigV4Signer = class {
+  async sign(httpRequest, identity, signingProperties) {
+    if (!HttpRequest.isInstance(httpRequest)) {
+      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
+    }
+    const validatedProps = await validateSigningProperties(signingProperties);
+    const { config, signer } = validatedProps;
+    let { signingRegion, signingName } = validatedProps;
+    const handlerExecutionContext = signingProperties.context;
+    if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
+      const [first, second] = handlerExecutionContext.authSchemes;
+      if (first?.name === "sigv4a" && second?.name === "sigv4") {
+        signingRegion = second?.signingRegion ?? signingRegion;
+        signingName = second?.signingName ?? signingName;
+      }
+    }
+    signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
+    const signedRequest = await signer.sign(httpRequest, {
+      signingDate: getSkewCorrectedDate(config.systemClockOffset),
+      signingRegion,
+      signingService: signingName
+    });
+    return signedRequest;
+  }
+  errorHandler(signingProperties) {
+    return (error) => {
+      const errorException = error;
+      const serverTime = errorException.ServerTime ?? getDateHeader(errorException.$response);
+      if (serverTime) {
+        const config = throwSigningPropertyError("config", signingProperties.config);
+        const preRequestOffset = signingProperties._preRequestSystemClockOffset;
+        const newOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
+        const isLocalCorrection = newOffset !== config.systemClockOffset;
+        const isConcurrentCorrection = preRequestOffset !== void 0 && preRequestOffset !== newOffset;
+        const clockSkewCorrected = isLocalCorrection || isConcurrentCorrection;
+        if (clockSkewCorrected && errorException.$metadata) {
+          config.systemClockOffset = newOffset;
+          errorException.$metadata.clockSkewCorrected = true;
+        }
+      }
+      throw error;
+    };
+  }
+  successHandler(httpResponse, signingProperties) {
+    const dateHeader = getDateHeader(httpResponse);
+    if (dateHeader) {
+      const config = throwSigningPropertyError("config", signingProperties.config);
+      config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4ASigner.js
+var AwsSdkSigV4ASigner = class extends AwsSdkSigV4Signer {
+  async sign(httpRequest, identity, signingProperties) {
+    if (!HttpRequest.isInstance(httpRequest)) {
+      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
+    }
+    const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
+    const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.();
+    const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(",");
+    signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
+    const signedRequest = await signer.sign(httpRequest, {
+      signingDate: getSkewCorrectedDate(config.systemClockOffset),
+      signingRegion: multiRegionOverride,
+      signingService: signingName
+    });
+    return signedRequest;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js
+var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js
+var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js
+var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
+var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
+var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
+  environmentVariableSelector: (env, options) => {
+    if (options?.signingName) {
+      const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
+      if (bearerTokenKey in env)
+        return ["httpBearerAuth"];
+    }
+    if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env))
+      return void 0;
+    return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
+  },
+  configFileSelector: (profile) => {
+    if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
+      return void 0;
+    return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
+  },
+  default: []
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.js
+var resolveAwsSdkSigV4AConfig = (config) => {
+  config.sigv4aSigningRegionSet = normalizeProvider(config.sigv4aSigningRegionSet);
+  return config;
+};
+var NODE_SIGV4A_CONFIG_OPTIONS = {
+  environmentVariableSelector(env) {
+    if (env.AWS_SIGV4A_SIGNING_REGION_SET) {
+      return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
+    }
+    throw new ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
+      tryNextLink: true
+    });
+  },
+  configFileSelector(profile) {
+    if (profile.sigv4a_signing_region_set) {
+      return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
+    }
+    throw new ProviderError("sigv4a_signing_region_set not set in profile.", {
+      tryNextLink: true
+    });
+  },
+  default: void 0
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js
+var resolveAwsSdkSigV4Config = (config) => {
+  let inputCredentials = config.credentials;
+  let isUserSupplied = !!config.credentials;
+  let resolvedCredentials = void 0;
+  Object.defineProperty(config, "credentials", {
+    set(credentials) {
+      if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) {
+        isUserSupplied = true;
+      }
+      inputCredentials = credentials;
+      const memoizedProvider = normalizeCredentialProvider(config, {
+        credentials: inputCredentials,
+        credentialDefaultProvider: config.credentialDefaultProvider
+      });
+      const boundProvider = bindCallerConfig(config, memoizedProvider);
+      if (isUserSupplied && !boundProvider.attributed) {
+        const isCredentialObject = typeof inputCredentials === "object" && inputCredentials !== null;
+        resolvedCredentials = async (options) => {
+          const creds = await boundProvider(options);
+          const attributedCreds = creds;
+          if (isCredentialObject && (!attributedCreds.$source || Object.keys(attributedCreds.$source).length === 0)) {
+            return setCredentialFeature(attributedCreds, "CREDENTIALS_CODE", "e");
+          }
+          return attributedCreds;
+        };
+        resolvedCredentials.memoized = boundProvider.memoized;
+        resolvedCredentials.configBound = boundProvider.configBound;
+        resolvedCredentials.attributed = true;
+      } else {
+        resolvedCredentials = boundProvider;
+      }
+    },
+    get() {
+      return resolvedCredentials;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  config.credentials = inputCredentials;
+  const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256 } = config;
+  let signer;
+  if (config.signer) {
+    signer = normalizeProvider(config.signer);
+  } else if (config.regionInfoProvider) {
+    signer = () => normalizeProvider(config.region)().then(async (region) => [
+      await config.regionInfoProvider(region, {
+        useFipsEndpoint: await config.useFipsEndpoint(),
+        useDualstackEndpoint: await config.useDualstackEndpoint()
+      }) || {},
+      region
+    ]).then(([regionInfo, region]) => {
+      const { signingRegion, signingService } = regionInfo;
+      config.signingRegion = config.signingRegion || signingRegion || region;
+      config.signingName = config.signingName || signingService || config.serviceId;
+      const params = {
+        ...config,
+        credentials: config.credentials,
+        region: config.signingRegion,
+        service: config.signingName,
+        sha256,
+        uriEscapePath: signingEscapePath
+      };
+      const SignerCtor = config.signerConstructor || SignatureV4;
+      return new SignerCtor(params);
+    });
+  } else {
+    signer = async (authScheme) => {
+      authScheme = Object.assign({}, {
+        name: "sigv4",
+        signingName: config.signingName || config.defaultSigningName,
+        signingRegion: await normalizeProvider(config.region)(),
+        properties: {}
+      }, authScheme);
+      const signingRegion = authScheme.signingRegion;
+      const signingService = authScheme.signingName;
+      config.signingRegion = config.signingRegion || signingRegion;
+      config.signingName = config.signingName || signingService || config.serviceId;
+      const params = {
+        ...config,
+        credentials: config.credentials,
+        region: config.signingRegion,
+        service: config.signingName,
+        sha256,
+        uriEscapePath: signingEscapePath
+      };
+      const SignerCtor = config.signerConstructor || SignatureV4;
+      return new SignerCtor(params);
+    };
+  }
+  const resolvedConfig = Object.assign(config, {
+    systemClockOffset,
+    signingEscapePath,
+    signer
+  });
+  return resolvedConfig;
+};
+function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider }) {
+  let credentialsProvider;
+  if (credentials) {
+    if (!credentials?.memoized) {
+      credentialsProvider = memoizeIdentityProvider(credentials, isIdentityExpired, doesIdentityRequireRefresh);
+    } else {
+      credentialsProvider = credentials;
+    }
+  } else {
+    if (credentialDefaultProvider) {
+      credentialsProvider = normalizeProvider(credentialDefaultProvider(Object.assign({}, config, {
+        parentClientConfig: config
+      })));
+    } else {
+      credentialsProvider = async () => {
+        throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
+      };
+    }
+  }
+  credentialsProvider.memoized = true;
+  return credentialsProvider;
+}
+function bindCallerConfig(config, credentialsProvider) {
+  if (credentialsProvider.configBound) {
+    return credentialsProvider;
+  }
+  const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
+  fn.memoized = credentialsProvider.memoized;
+  fn.configBound = true;
+  return fn;
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ProtocolLib.js
+var ProtocolLib = class {
+  queryCompat;
+  errorRegistry;
+  constructor(queryCompat = false) {
+    this.queryCompat = queryCompat;
+  }
+  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 errorName = errorIdentifier;
+    if (errorIdentifier.includes("#")) {
+      [, errorName] = errorIdentifier.split("#");
+    }
+    const errorMetadata = {
+      $metadata: metadata,
+      $fault: response.statusCode < 500 ? "client" : "server"
+    };
+    if (!this.errorRegistry) {
+      throw new Error("@aws-sdk/core/protocols - error handler not initialized.");
+    }
+    try {
+      const errorSchema = getErrorSchema?.(this.errorRegistry, errorName) ?? this.errorRegistry.getSchema(errorIdentifier);
+      return { errorSchema, errorMetadata };
+    } catch (e) {
+      dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError";
+      const synthetic = this.errorRegistry;
+      const baseExceptionSchema = synthetic.getBaseException();
+      if (baseExceptionSchema) {
+        const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error;
+        throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject);
+      }
+      const d = dataObject;
+      const message = d?.message ?? d?.Message ?? d?.Error?.Message ?? d?.Error?.message;
+      throw this.decorateServiceException(Object.assign(new Error(message), {
+        name: errorName
+      }, errorMetadata), dataObject);
+    }
+  }
+  compose(composite, errorIdentifier, defaultNamespace) {
+    let namespace = defaultNamespace;
+    if (errorIdentifier.includes("#")) {
+      [namespace] = errorIdentifier.split("#");
+    }
+    const staticRegistry = TypeRegistry.for(namespace);
+    const defaultSyntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + defaultNamespace);
+    composite.copyFrom(staticRegistry);
+    composite.copyFrom(defaultSyntheticRegistry);
+    this.errorRegistry = composite;
+  }
+  decorateServiceException(exception, additions = {}) {
+    if (this.queryCompat) {
+      const msg = exception.Message ?? additions.Message;
+      const error = decorateServiceException(exception, additions);
+      if (msg) {
+        error.message = msg;
+      }
+      const errorObj = error.Error ?? {};
+      errorObj.Type = error.Error?.Type;
+      errorObj.Code = error.Error?.Code;
+      errorObj.Message = error.Error?.message ?? error.Error?.Message ?? msg;
+      error.Error = errorObj;
+      const reqId = error.$metadata.requestId;
+      if (reqId) {
+        error.RequestId = reqId;
+      }
+      return error;
+    }
+    return decorateServiceException(exception, additions);
+  }
+  setQueryCompatError(output, response) {
+    const queryErrorHeader = response.headers?.["x-amzn-query-error"];
+    if (output !== void 0 && queryErrorHeader != null) {
+      const [Code, Type] = queryErrorHeader.split(";");
+      const keys = Object.keys(output);
+      const Error2 = {
+        Code,
+        Type
+      };
+      output.Code = Code;
+      output.Type = Type;
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        Error2[k === "message" ? "Message" : k] = output[k];
+      }
+      delete Error2.__type;
+      output.Error = Error2;
+    }
+  }
+  queryCompatOutput(queryCompatErrorData, errorData) {
+    if (queryCompatErrorData.Error) {
+      errorData.Error = queryCompatErrorData.Error;
+    }
+    if (queryCompatErrorData.Type) {
+      errorData.Type = queryCompatErrorData.Type;
+    }
+    if (queryCompatErrorData.Code) {
+      errorData.Code = queryCompatErrorData.Code;
+    }
+  }
+  findQueryCompatibleError(registry, errorName) {
+    try {
+      return registry.getSchema(errorName);
+    } catch (e) {
+      return registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ConfigurableSerdeContext.js
+var SerdeContextConfig = class {
+  serdeContext;
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/UnionSerde.js
+var UnionSerde = class {
+  from;
+  to;
+  keys;
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+    const keys = Object.keys(this.from);
+    const set = new Set(keys);
+    set.delete("__type");
+    this.keys = set;
+  }
+  mark(key) {
+    this.keys.delete(key);
+  }
+  hasUnknown() {
+    return this.keys.size === 1 && Object.keys(this.to).length === 0;
+  }
+  writeUnknown() {
+    if (this.hasUnknown()) {
+      const k = this.keys.values().next().value;
+      const v = this.from[k];
+      this.to.$unknown = [k, v];
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReviver.js
+function jsonReviver(key, value, context) {
+  if (context?.source) {
+    const numericString = context.source;
+    if (typeof value === "number") {
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER || numericString !== String(value)) {
+        const isFractional = numericString.includes(".");
+        if (isFractional) {
+          return new NumericValue(numericString, "bigDecimal");
+        } else {
+          return BigInt(numericString);
+        }
+      }
+    }
+  }
+  return value;
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js
+var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/parseJsonBody.js
+var parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    try {
+      return JSON.parse(encoded);
+    } catch (e) {
+      if (e?.name === "SyntaxError") {
+        Object.defineProperty(e, "$responseBodyText", {
+          value: encoded
+        });
+      }
+      throw e;
+    }
+  }
+  return {};
+});
+var findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+var sanitizeErrorCode = (rawValue) => {
+  let cleanValue = rawValue;
+  if (typeof cleanValue === "number") {
+    cleanValue = cleanValue.toString();
+  }
+  if (cleanValue.indexOf(",") >= 0) {
+    cleanValue = cleanValue.split(",")[0];
+  }
+  if (cleanValue.indexOf(":") >= 0) {
+    cleanValue = cleanValue.split(":")[0];
+  }
+  if (cleanValue.indexOf("#") >= 0) {
+    cleanValue = cleanValue.split("#")[1];
+  }
+  return cleanValue;
+};
+var loadRestJsonErrorCode = (output, data) => {
+  return loadErrorCode(output, data, ["header", "code", "type"]);
+};
+var loadErrorCode = ({ headers }, data, order) => {
+  while (order.length > 0) {
+    const location = order.shift();
+    switch (location) {
+      case "header":
+        const headerKey = findKey(headers ?? {}, "x-amzn-errortype");
+        if (headerKey !== void 0) {
+          return sanitizeErrorCode(headers[headerKey]);
+        }
+        break;
+      case "code":
+        const codeKey = findKey(data ?? {}, "code");
+        if (codeKey && data[codeKey] !== void 0) {
+          return sanitizeErrorCode(data[codeKey]);
+        }
+        break;
+      case "type":
+        if (data?.__type !== void 0) {
+          return sanitizeErrorCode(data.__type);
+        }
+        break;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeDeserializer.js
+var JsonShapeDeserializer = class extends SerdeContextConfig {
+  settings;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  async read(schema, data) {
+    return this._read(schema, typeof data === "string" ? JSON.parse(data, jsonReviver) : await parseJsonBody(data, this.serdeContext));
+  }
+  readObject(schema, data) {
+    return this._read(schema, data);
+  }
+  _read(schema, value) {
+    const isObject = value !== null && typeof value === "object";
+    const ns = NormalizedSchema.of(schema);
+    if (isObject) {
+      if (ns.isStructSchema()) {
+        const record = value;
+        const union = ns.isUnionSchema();
+        const out = {};
+        let nameMap = void 0;
+        const { jsonName } = this.settings;
+        if (jsonName) {
+          nameMap = {};
+        }
+        let unionSerde;
+        if (union) {
+          unionSerde = new UnionSerde(record, out);
+        }
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+          let fromKey = memberName;
+          if (jsonName) {
+            fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
+            nameMap[fromKey] = memberName;
+          }
+          if (union) {
+            unionSerde.mark(fromKey);
+          }
+          if (record[fromKey] != null) {
+            out[memberName] = this._read(memberSchema, record[fromKey]);
+          }
+        }
+        if (union) {
+          unionSerde.writeUnknown();
+        } else if (typeof record.__type === "string") {
+          for (const k in record) {
+            const v = record[k];
+            const t = jsonName ? nameMap[k] ?? k : k;
+            if (!(t in out)) {
+              out[t] = v;
+            }
+          }
+        }
+        return out;
+      }
+      if (Array.isArray(value) && ns.isListSchema()) {
+        const listMember = ns.getValueSchema();
+        const out = [];
+        for (const item of value) {
+          out.push(this._read(listMember, item));
+        }
+        return out;
+      }
+      if (ns.isMapSchema()) {
+        const mapMember = ns.getValueSchema();
+        const out = {};
+        for (const _k in value) {
+          out[_k] = this._read(mapMember, value[_k]);
+        }
+        return out;
+      }
+    }
+    if (ns.isBlobSchema() && typeof value === "string") {
+      return fromBase64(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);
+      }
+      return value;
+    }
+    if (ns.isTimestampSchema() && value != null) {
+      const format = determineTimestampFormat(ns, this.settings);
+      switch (format) {
+        case 5:
+          return parseRfc3339DateTimeWithOffset(value);
+        case 6:
+          return parseRfc7231DateTime(value);
+        case 7:
+          return parseEpochTimestamp(value);
+        default:
+          console.warn("Missing timestamp format, parsing value with Date constructor:", value);
+          return new Date(value);
+      }
+    }
+    if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
+      return BigInt(value);
+    }
+    if (ns.isBigDecimalSchema() && value != void 0) {
+      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") {
+      switch (value) {
+        case "Infinity":
+          return Infinity;
+        case "-Infinity":
+          return -Infinity;
+        case "NaN":
+          return NaN;
+      }
+      return value;
+    }
+    if (ns.isDocumentSchema()) {
+      if (isObject) {
+        const out = Array.isArray(value) ? [] : {};
+        for (const k in value) {
+          const v = value[k];
+          if (v instanceof NumericValue) {
+            out[k] = v;
+          } else {
+            out[k] = this._read(ns, v);
+          }
+        }
+        return out;
+      } else {
+        return structuredClone(value);
+      }
+    }
+    return value;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReplacer.js
+var NUMERIC_CONTROL_CHAR = String.fromCharCode(925);
+var JsonReplacer = class {
+  values = /* @__PURE__ */ new Map();
+  counter = 0;
+  stage = 0;
+  createReplacer() {
+    if (this.stage === 1) {
+      throw new Error("@aws-sdk/core/protocols - JsonReplacer already created.");
+    }
+    if (this.stage === 2) {
+      throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
+    }
+    this.stage = 1;
+    return (key, value) => {
+      if (value instanceof NumericValue) {
+        const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string;
+        this.values.set(`"${v}"`, value.string);
+        return v;
+      }
+      if (typeof value === "bigint") {
+        const s = value.toString();
+        const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s;
+        this.values.set(`"${v}"`, s);
+        return v;
+      }
+      return value;
+    };
+  }
+  replaceInJson(json) {
+    if (this.stage === 0) {
+      throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet.");
+    }
+    if (this.stage === 2) {
+      throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
+    }
+    this.stage = 2;
+    if (this.counter === 0) {
+      return json;
+    }
+    for (const [key, value] of this.values) {
+      json = json.replace(key, value);
+    }
+    return json;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonShapeSerializer.js
+var JsonShapeSerializer = class extends SerdeContextConfig {
+  settings;
+  buffer;
+  useReplacer = false;
+  rootSchema;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  write(schema, value) {
+    this.rootSchema = NormalizedSchema.of(schema);
+    this.buffer = this._write(this.rootSchema, value);
+  }
+  flush() {
+    const { rootSchema, useReplacer } = this;
+    this.rootSchema = void 0;
+    this.useReplacer = false;
+    if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) {
+      if (!useReplacer) {
+        return JSON.stringify(this.buffer);
+      }
+      const replacer = new JsonReplacer();
+      return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0));
+    }
+    return this.buffer;
+  }
+  writeDiscriminatedDocument(schema, value) {
+    this.write(schema, value);
+    if (typeof this.buffer === "object") {
+      this.buffer.__type = NormalizedSchema.of(schema).getName(true);
+    }
+  }
+  _write(schema, value, container) {
+    const isObject = value !== null && typeof value === "object";
+    const ns = NormalizedSchema.of(schema);
+    if (isObject) {
+      if (ns.isStructSchema()) {
+        const record = value;
+        const out = {};
+        const { jsonName } = this.settings;
+        let nameMap = void 0;
+        if (jsonName) {
+          nameMap = {};
+        }
+        let outCount = 0;
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+          const serializableValue = this._write(memberSchema, record[memberName], ns);
+          if (serializableValue !== void 0) {
+            let targetKey = memberName;
+            if (jsonName) {
+              targetKey = memberSchema.getMergedTraits().jsonName ?? memberName;
+              nameMap[memberName] = targetKey;
+            }
+            out[targetKey] = serializableValue;
+            outCount++;
+          }
+        }
+        if (ns.isUnionSchema() && outCount === 0) {
+          const { $unknown } = record;
+          if (Array.isArray($unknown)) {
+            const [k, v] = $unknown;
+            out[k] = this._write(15, v);
+          }
+        } else if (typeof record.__type === "string") {
+          for (const k in record) {
+            const v = record[k];
+            const targetKey = jsonName ? nameMap[k] ?? k : k;
+            if (!(targetKey in out)) {
+              out[targetKey] = this._write(15, v);
+            }
+          }
+        }
+        return out;
+      }
+      if (Array.isArray(value) && ns.isListSchema()) {
+        const listMember = ns.getValueSchema();
+        const out = [];
+        const sparse = !!ns.getMergedTraits().sparse;
+        for (const item of value) {
+          if (sparse || item != null) {
+            out.push(this._write(listMember, item));
+          }
+        }
+        return out;
+      }
+      if (ns.isMapSchema()) {
+        const mapMember = ns.getValueSchema();
+        const out = {};
+        const sparse = !!ns.getMergedTraits().sparse;
+        for (const _k in value) {
+          const _v = value[_k];
+          if (sparse || _v != null) {
+            out[_k] = this._write(mapMember, _v);
+          }
+        }
+        return out;
+      }
+      if (value instanceof Uint8Array && (ns.isBlobSchema() || ns.isDocumentSchema())) {
+        if (ns === this.rootSchema) {
+          return value;
+        }
+        return (this.serdeContext?.base64Encoder ?? toBase64)(value);
+      }
+      if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
+        const format = determineTimestampFormat(ns, this.settings);
+        switch (format) {
+          case 5:
+            return value.toISOString().replace(".000Z", "Z");
+          case 6:
+            return dateToUtcString(value);
+          case 7:
+            return value.getTime() / 1e3;
+          default:
+            console.warn("Missing timestamp format, using epoch seconds", value);
+            return value.getTime() / 1e3;
+        }
+      }
+      if (value instanceof NumericValue) {
+        this.useReplacer = true;
+      }
+    }
+    if (value === null && container?.isStructSchema()) {
+      return void 0;
+    }
+    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);
+        }
+      }
+      return value;
+    }
+    if (typeof value === "number" && ns.isNumericSchema()) {
+      if (Math.abs(value) === Infinity || isNaN(value)) {
+        return String(value);
+      }
+      return value;
+    }
+    if (typeof value === "string" && ns.isBlobSchema()) {
+      if (ns === this.rootSchema) {
+        return value;
+      }
+      return (this.serdeContext?.base64Encoder ?? toBase64)(value);
+    }
+    if (typeof value === "bigint") {
+      this.useReplacer = true;
+    }
+    if (ns.isDocumentSchema()) {
+      if (isObject) {
+        const out = Array.isArray(value) ? [] : {};
+        for (const k in value) {
+          const v = value[k];
+          if (v instanceof NumericValue) {
+            this.useReplacer = true;
+            out[k] = v;
+          } else {
+            out[k] = this._write(ns, v);
+          }
+        }
+        return out;
+      } else {
+        return structuredClone(value);
+      }
+    }
+    return value;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/JsonCodec.js
+var JsonCodec = class extends SerdeContextConfig {
+  settings;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  createSerializer() {
+    const serializer = new JsonShapeSerializer(this.settings);
+    serializer.setSerdeContext(this.serdeContext);
+    return serializer;
+  }
+  createDeserializer() {
+    const deserializer = new JsonShapeDeserializer(this.settings);
+    deserializer.setSerdeContext(this.serdeContext);
+    return deserializer;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsRestJsonProtocol.js
+var AwsRestJsonProtocol = class extends HttpBindingProtocol {
+  serializer;
+  deserializer;
+  codec;
+  mixin = new ProtocolLib();
+  constructor({ defaultNamespace, errorTypeRegistries }) {
+    super({
+      defaultNamespace,
+      errorTypeRegistries
+    });
+    const settings = {
+      timestampFormat: {
+        useTrait: true,
+        default: 7
+      },
+      httpBindings: true,
+      jsonName: true
+    };
+    this.codec = new JsonCodec(settings);
+    this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
+    this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
+  }
+  getShapeId() {
+    return "aws.protocols#restJson1";
+  }
+  getPayloadCodec() {
+    return this.codec;
+  }
+  setSerdeContext(serdeContext) {
+    this.codec.setSerdeContext(serdeContext);
+    super.setSerdeContext(serdeContext);
+  }
+  async serializeRequest(operationSchema, input, context) {
+    const request = await super.serializeRequest(operationSchema, input, context);
+    const inputSchema = NormalizedSchema.of(operationSchema.input);
+    if (!request.headers["content-type"]) {
+      const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
+      if (contentType) {
+        request.headers["content-type"] = contentType;
+      }
+    }
+    if (request.body == null && request.headers["content-type"] === this.getDefaultContentType()) {
+      request.body = "{}";
+    }
+    return request;
+  }
+  async deserializeResponse(operationSchema, context, response) {
+    const output = await super.deserializeResponse(operationSchema, context, response);
+    const outputSchema = NormalizedSchema.of(operationSchema.output);
+    for (const [name, member] of outputSchema.structIterator()) {
+      if (member.getMemberTraits().httpPayload && !(name in output)) {
+        output[name] = null;
+      }
+    }
+    return output;
+  }
+  async handleError(operationSchema, context, response, dataObject, metadata) {
+    const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
+    this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
+    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 ?? "UnknownError";
+    const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
+    const exception = new ErrorCtor({});
+    await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+    const output = {};
+    const errorDeserializer = this.codec.createDeserializer();
+    for (const [name, member] of ns.structIterator()) {
+      const target = member.getMergedTraits().jsonName ?? name;
+      output[name] = errorDeserializer.readObject(member, dataObject[target]);
+    }
+    throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
+      $fault: ns.getMergedTraits().error,
+      message
+    }, output), dataObject);
+  }
+  getDefaultContentType() {
+    return "application/json";
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.972.36/node_modules/@aws-sdk/xml-builder/dist-es/xml-parser.js
+function parseXML(xml) {
+  const state = new AwsXmlParser(xml);
+  return state.parse();
+}
+var AwsXmlParser = class _AwsXmlParser {
+  x;
+  i = 0;
+  z;
+  constructor(x) {
+    this.x = x;
+    this.x = x.replace(/\r\n?/g, "\n");
+    this.z = this.x.length;
+  }
+  parse() {
+    const p = this;
+    const { z } = p;
+    while (p.i < z) {
+      p.trim();
+      if (p.i >= z) {
+        break;
+      }
+      if (p.isNext("<?")) {
+        p.readTo("?>");
+        p.trim();
+      } else if (p.isNext("<!--")) {
+        p.readTo("-->");
+        p.trim();
+      } else if (p.isNext("<!DOCTYPE", false)) {
+        p.skipDoctype();
+        p.trim();
+      } else if (p.x[p.i] === "<") {
+        const root = p.parseTag();
+        return { [root.tag]: root.value };
+      } else {
+        throw new Error("@aws-sdk XML parse error: unexpected content.");
+      }
+    }
+    throw new Error("@aws-sdk XML parse error: no root element.");
+  }
+  isNext(s, caseSensitive = true) {
+    const p = this;
+    if (caseSensitive) {
+      return p.x.startsWith(s, p.i);
+    }
+    return p.x.toLowerCase().startsWith(s.toLowerCase(), p.i);
+  }
+  readTo(stop) {
+    const p = this;
+    const _i = p.x.indexOf(stop, p.i);
+    if (_i === -1) {
+      throw new Error(`@aws-sdk XML parse error: expected "${stop}" not found.`);
+    }
+    const result = p.x.slice(p.i, _i);
+    p.i = _i + stop.length;
+    return result;
+  }
+  trim() {
+    const p = this;
+    while (p.i < p.z && " 	\r\n".includes(p.x[p.i])) {
+      ++p.i;
+    }
+  }
+  readAttrValue() {
+    const p = this;
+    const quote = p.x[p.i];
+    ++p.i;
+    let value = "";
+    while (p.i < p.z && p.x[p.i] !== quote) {
+      value += p.x[p.i++];
+    }
+    ++p.i;
+    return p.decodeEntities(value);
+  }
+  parseTag() {
+    const p = this;
+    ++p.i;
+    let tag = "";
+    while (p.i < p.z && !" 	\r\n>/".includes(p.x[p.i])) {
+      tag += p.x[p.i++];
+    }
+    let hasAttrs = false;
+    const attrs = /* @__PURE__ */ Object.create(null);
+    while (p.i < p.z) {
+      p.trim();
+      if (">/".includes(p.x[p.i])) {
+        break;
+      }
+      let name = "";
+      while (p.i < p.z && !"= 	\r\n>/?".includes(p.x[p.i])) {
+        name += p.x[p.i++];
+      }
+      p.trim();
+      if (p.x[p.i] !== "=") {
+        break;
+      }
+      ++p.i;
+      p.trim();
+      attrs[name] = p.readAttrValue();
+      hasAttrs = true;
+    }
+    if (p.i >= p.z) {
+      throw new Error("@aws-sdk XML parse error: unexpected end of input.");
+    }
+    if (p.x[p.i] === "/") {
+      ++p.i;
+      if (p.i >= p.z || p.x[p.i] !== ">") {
+        throw new Error("@aws-sdk XML parse error: expected > at the end of self-closing tag.");
+      }
+      ++p.i;
+      Object.setPrototypeOf(attrs, Object.prototype);
+      return { tag, value: hasAttrs ? attrs : "" };
+    }
+    if (p.x[p.i] !== ">") {
+      throw new Error("@aws-sdk XML parse error: expected > at the end of opening tag.");
+    }
+    ++p.i;
+    const textParts = [];
+    const childTags = [];
+    let hasElementChild = false;
+    while (p.i < p.z) {
+      if (p.isNext("</")) {
+        break;
+      }
+      if (p.x[p.i] === "<") {
+        if (p.isNext("<!--")) {
+          p.readTo("-->");
+        } else if (p.isNext("<![CDATA[")) {
+          p.i += 9;
+          textParts.push(p.readTo("]]>"));
+        } else if (p.isNext("<?")) {
+          p.readTo("?>");
+        } else {
+          hasElementChild = true;
+          childTags.push(p.parseTag());
+        }
+      } else {
+        let text = "";
+        while (p.i < p.z && p.x[p.i] !== "<") {
+          text += p.x[p.i++];
+        }
+        textParts.push(p.decodeEntities(text));
+      }
+    }
+    if (!p.isNext("</")) {
+      throw new Error(`@aws-sdk XML parse error: missing closing tag </${tag}>.`);
+    }
+    p.i += 2;
+    const closeTag = p.readTo(">").trim();
+    if (closeTag !== tag) {
+      throw new Error(`@aws-sdk XML parse error: mismatched tags <${tag}> and </${closeTag}>.`);
+    }
+    if (!hasAttrs && textParts.length === 0 && !hasElementChild) {
+      return { tag, value: "" };
+    }
+    if (!hasAttrs && !hasElementChild) {
+      const text = textParts.length === 1 ? textParts[0] : textParts.join("");
+      if (text.trim() === "" && text.includes("\n")) {
+        return { tag, value: "" };
+      }
+      return { tag, value: text };
+    }
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (const text of textParts) {
+      if (text.trim() === "" && text.includes("\n")) {
+        continue;
+      }
+      obj["#text"] = "#text" in obj ? obj["#text"] + text : text;
+    }
+    for (const child of childTags) {
+      if (child.tag in obj) {
+        if (Array.isArray(obj[child.tag])) {
+          obj[child.tag].push(child.value);
+        } else {
+          obj[child.tag] = [obj[child.tag], child.value];
+        }
+      } else {
+        obj[child.tag] = child.value;
+      }
+    }
+    for (const [k, v] of Object.entries(attrs)) {
+      obj[k] = v;
+    }
+    Object.setPrototypeOf(obj, Object.prototype);
+    return { tag, value: obj };
+  }
+  static ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'"
+  };
+  skipDoctype() {
+    const p = this;
+    p.i += 9;
+    let depth = 0;
+    while (p.i < p.z) {
+      const c = p.x[p.i];
+      if (c === "[") {
+        ++depth;
+      } else if (c === "]") {
+        --depth;
+      } else if (c === ">" && depth === 0) {
+        ++p.i;
+        return;
+      }
+      ++p.i;
+    }
+    throw new Error("@aws-sdk XML parse error: unclosed DOCTYPE.");
+  }
+  decodeEntities(s) {
+    return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{0,30}));/g, (_, hex, dec, named) => {
+      if (hex) {
+        return String.fromCharCode(parseInt(hex, 16));
+      }
+      if (dec) {
+        return String.fromCharCode(parseInt(dec, 10));
+      }
+      return _AwsXmlParser.ENTITIES[named] ?? "";
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/XmlShapeDeserializer.js
+var XmlShapeDeserializer = class extends SerdeContextConfig {
+  settings;
+  stringDeserializer;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+    this.stringDeserializer = new FromStringShapeDeserializer(settings);
+  }
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+    this.stringDeserializer.setSerdeContext(serdeContext);
+  }
+  read(schema, bytes, key) {
+    const ns = NormalizedSchema.of(schema);
+    const memberSchemas = ns.getMemberSchemas();
+    const isEventPayload = ns.isStructSchema() && ns.isMemberSchema() && !!Object.values(memberSchemas).find((memberNs) => {
+      return !!memberNs.getMemberTraits().eventPayload;
+    });
+    if (isEventPayload) {
+      const output = {};
+      const memberName = Object.keys(memberSchemas)[0];
+      const eventMemberSchema = memberSchemas[memberName];
+      if (eventMemberSchema.isBlobSchema()) {
+        output[memberName] = bytes;
+      } else {
+        output[memberName] = this.read(memberSchemas[memberName], bytes);
+      }
+      return output;
+    }
+    const xmlString = (this.serdeContext?.utf8Encoder ?? toUtf8)(bytes);
+    const parsedObject = this.parseXml(xmlString);
+    return this.readSchema(schema, key ? parsedObject[key] : parsedObject);
+  }
+  readSchema(_schema, value) {
+    const ns = NormalizedSchema.of(_schema);
+    if (ns.isUnitSchema()) {
+      return;
+    }
+    const traits = ns.getMergedTraits();
+    if (ns.isListSchema() && !Array.isArray(value)) {
+      return this.readSchema(ns, [value]);
+    }
+    if (value == null) {
+      return value;
+    }
+    if (typeof value === "object") {
+      const flat = !!traits.xmlFlattened;
+      if (ns.isListSchema()) {
+        const listValue = ns.getValueSchema();
+        const buffer2 = [];
+        const sourceKey = listValue.getMergedTraits().xmlName ?? "member";
+        const source = flat ? value : (value[0] ?? value)[sourceKey];
+        if (source == null) {
+          return buffer2;
+        }
+        const sourceArray = Array.isArray(source) ? source : [source];
+        for (const v of sourceArray) {
+          buffer2.push(this.readSchema(listValue, v));
+        }
+        return buffer2;
+      }
+      const buffer = {};
+      if (ns.isMapSchema()) {
+        const keyNs = ns.getKeySchema();
+        const memberNs = ns.getValueSchema();
+        let entries;
+        if (flat) {
+          entries = Array.isArray(value) ? value : [value];
+        } else {
+          entries = Array.isArray(value.entry) ? value.entry : [value.entry];
+        }
+        const keyProperty = keyNs.getMergedTraits().xmlName ?? "key";
+        const valueProperty = memberNs.getMergedTraits().xmlName ?? "value";
+        for (const entry of entries) {
+          const key = entry[keyProperty];
+          const value2 = entry[valueProperty];
+          buffer[key] = this.readSchema(memberNs, value2);
+        }
+        return buffer;
+      }
+      if (ns.isStructSchema()) {
+        const union = ns.isUnionSchema();
+        let unionSerde;
+        if (union) {
+          unionSerde = new UnionSerde(value, buffer);
+        }
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+          const memberTraits = memberSchema.getMergedTraits();
+          const xmlObjectKey = !memberTraits.httpPayload ? memberSchema.getMemberTraits().xmlName ?? memberName : memberTraits.xmlName ?? memberSchema.getName();
+          if (union) {
+            unionSerde.mark(xmlObjectKey);
+          }
+          if (value[xmlObjectKey] != null) {
+            buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]);
+          }
+        }
+        if (union) {
+          unionSerde.writeUnknown();
+        }
+        return buffer;
+      }
+      if (ns.isDocumentSchema()) {
+        return value;
+      }
+      throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`);
+    }
+    if (ns.isListSchema()) {
+      return [];
+    }
+    if (ns.isMapSchema() || ns.isStructSchema()) {
+      return {};
+    }
+    return this.stringDeserializer.read(ns, value);
+  }
+  parseXml(xml) {
+    if (xml.length) {
+      let parsedObj;
+      try {
+        parsedObj = parseXML(xml);
+      } catch (e) {
+        if (e && typeof e === "object") {
+          Object.defineProperty(e, "$responseBodyText", {
+            value: xml
+          });
+        }
+        throw e;
+      }
+      const textNodeName = "#text";
+      const key = Object.keys(parsedObj)[0];
+      const parsedObjToReturn = parsedObj[key];
+      if (parsedObjToReturn[textNodeName]) {
+        parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+        delete parsedObjToReturn[textNodeName];
+      }
+      return getValueFromTextNode(parsedObjToReturn);
+    }
+    return {};
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/QueryShapeSerializer.js
+var QueryShapeSerializer = class extends SerdeContextConfig {
+  settings;
+  buffer;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  write(schema, value, prefix = "") {
+    if (this.buffer === void 0) {
+      this.buffer = "";
+    }
+    const ns = NormalizedSchema.of(schema);
+    if (prefix && !prefix.endsWith(".")) {
+      prefix += ".";
+    }
+    if (ns.isBlobSchema()) {
+      if (typeof value === "string" || value instanceof Uint8Array) {
+        this.writeKey(prefix);
+        this.writeValue((this.serdeContext?.base64Encoder ?? toBase64)(value));
+      }
+    } else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      } else if (ns.isIdempotencyToken()) {
+        this.writeKey(prefix);
+        this.writeValue(generateIdempotencyToken());
+      }
+    } else if (ns.isBigIntegerSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      }
+    } else if (ns.isBigDecimalSchema()) {
+      if (value != null) {
+        this.writeKey(prefix);
+        this.writeValue(value instanceof NumericValue ? value.string : String(value));
+      }
+    } else if (ns.isTimestampSchema()) {
+      if (value instanceof Date) {
+        this.writeKey(prefix);
+        const format = determineTimestampFormat(ns, this.settings);
+        switch (format) {
+          case 5:
+            this.writeValue(value.toISOString().replace(".000Z", "Z"));
+            break;
+          case 6:
+            this.writeValue(dateToUtcString(value));
+            break;
+          case 7:
+            this.writeValue(String(value.getTime() / 1e3));
+            break;
+        }
+      }
+    } else if (ns.isDocumentSchema()) {
+      if (Array.isArray(value)) {
+        this.write(64 | 15, value, prefix);
+      } else if (value instanceof Date) {
+        this.write(4, value, prefix);
+      } else if (value instanceof Uint8Array) {
+        this.write(21, value, prefix);
+      } else if (value && typeof value === "object") {
+        this.write(128 | 15, value, prefix);
+      } else {
+        this.writeKey(prefix);
+        this.writeValue(String(value));
+      }
+    } else if (ns.isListSchema()) {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          if (this.settings.serializeEmptyLists) {
+            this.writeKey(prefix);
+            this.writeValue("");
+          }
+        } else {
+          const member = ns.getValueSchema();
+          const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened;
+          let i = 1;
+          for (const item of value) {
+            if (item == null) {
+              continue;
+            }
+            const traits = member.getMergedTraits();
+            const suffix = this.getKey("member", traits.xmlName, traits.ec2QueryName);
+            const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`;
+            this.write(member, item, key);
+            ++i;
+          }
+        }
+      }
+    } else if (ns.isMapSchema()) {
+      if (value && typeof value === "object") {
+        const keySchema = ns.getKeySchema();
+        const memberSchema = ns.getValueSchema();
+        const flat = ns.getMergedTraits().xmlFlattened;
+        let i = 1;
+        for (const k in value) {
+          const v = value[k];
+          if (v == null) {
+            continue;
+          }
+          const keyTraits = keySchema.getMergedTraits();
+          const keySuffix = this.getKey("key", keyTraits.xmlName, keyTraits.ec2QueryName);
+          const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`;
+          const valTraits = memberSchema.getMergedTraits();
+          const valueSuffix = this.getKey("value", valTraits.xmlName, valTraits.ec2QueryName);
+          const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`;
+          this.write(keySchema, k, key);
+          this.write(memberSchema, v, valueKey);
+          ++i;
+        }
+      }
+    } else if (ns.isStructSchema()) {
+      if (value && typeof value === "object") {
+        let didWriteMember = false;
+        for (const [memberName, member] of ns.structIterator()) {
+          if (value[memberName] == null && !member.isIdempotencyToken()) {
+            continue;
+          }
+          const traits = member.getMergedTraits();
+          const suffix = this.getKey(memberName, traits.xmlName, traits.ec2QueryName, "struct");
+          const key = `${prefix}${suffix}`;
+          this.write(member, value[memberName], key);
+          didWriteMember = true;
+        }
+        if (!didWriteMember && ns.isUnionSchema()) {
+          const { $unknown } = value;
+          if (Array.isArray($unknown)) {
+            const [k, v] = $unknown;
+            const key = `${prefix}${k}`;
+            this.write(15, v, key);
+          }
+        }
+      }
+    } else if (ns.isUnitSchema()) {
+    } else {
+      throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`);
+    }
+  }
+  flush() {
+    if (this.buffer === void 0) {
+      throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer.");
+    }
+    const str = this.buffer;
+    delete this.buffer;
+    return str;
+  }
+  getKey(memberName, xmlName, ec2QueryName, keySource) {
+    const { ec2, capitalizeKeys } = this.settings;
+    if (ec2 && ec2QueryName) {
+      return ec2QueryName;
+    }
+    const key = xmlName ?? memberName;
+    if (capitalizeKeys && keySource === "struct") {
+      return key[0].toUpperCase() + key.slice(1);
+    }
+    return key;
+  }
+  writeKey(key) {
+    if (key.endsWith(".")) {
+      key = key.slice(0, key.length - 1);
+    }
+    this.buffer += `&${extendedEncodeURIComponent(key)}=`;
+  }
+  writeValue(value) {
+    this.buffer += extendedEncodeURIComponent(value);
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.975.3/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/AwsQueryProtocol.js
+var AwsQueryProtocol = class extends RpcProtocol {
+  options;
+  serializer;
+  deserializer;
+  mixin = new ProtocolLib();
+  constructor(options) {
+    super({
+      defaultNamespace: options.defaultNamespace,
+      errorTypeRegistries: options.errorTypeRegistries
+    });
+    this.options = options;
+    const settings = {
+      timestampFormat: {
+        useTrait: true,
+        default: 5
+      },
+      httpBindings: false,
+      xmlNamespace: options.xmlNamespace,
+      serviceNamespace: options.defaultNamespace,
+      serializeEmptyLists: true
+    };
+    this.serializer = new QueryShapeSerializer(settings);
+    this.deserializer = new XmlShapeDeserializer(settings);
+  }
+  getShapeId() {
+    return "aws.protocols#awsQuery";
+  }
+  setSerdeContext(serdeContext) {
+    this.serializer.setSerdeContext(serdeContext);
+    this.deserializer.setSerdeContext(serdeContext);
+  }
+  getPayloadCodec() {
+    throw new Error("AWSQuery protocol has no payload codec.");
+  }
+  async serializeRequest(operationSchema, input, context) {
+    const request = await super.serializeRequest(operationSchema, input, context);
+    if (!request.path.endsWith("/")) {
+      request.path += "/";
+    }
+    request.headers["content-type"] = "application/x-www-form-urlencoded";
+    if (deref(operationSchema.input) === "unit" || !request.body) {
+      request.body = "";
+    }
+    const action = operationSchema.name.split("#")[1] ?? operationSchema.name;
+    request.body = `Action=${action}&Version=${this.options.version}` + request.body;
+    if (request.body.endsWith("&")) {
+      request.body = request.body.slice(-1);
+    }
+    return request;
+  }
+  async deserializeResponse(operationSchema, context, response) {
+    const deserializer = this.deserializer;
+    const ns = NormalizedSchema.of(operationSchema.output);
+    const dataObject = {};
+    if (response.statusCode >= 300) {
+      const bytes2 = await collectBody(response.body, context);
+      if (bytes2.byteLength > 0) {
+        Object.assign(dataObject, await deserializer.read(15, bytes2));
+      }
+      await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+    }
+    for (const header in response.headers) {
+      const value = response.headers[header];
+      delete response.headers[header];
+      response.headers[header.toLowerCase()] = value;
+    }
+    const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name;
+    const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : void 0;
+    const bytes = await collectBody(response.body, context);
+    if (bytes.byteLength > 0) {
+      Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
+    }
+    dataObject.$metadata = this.deserializeMetadata(response);
+    return dataObject;
+  }
+  useNestedResult() {
+    return true;
+  }
+  async handleError(operationSchema, context, response, dataObject, metadata) {
+    const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
+    this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
+    const errorData = this.loadQueryError(dataObject) ?? {};
+    const message = this.loadQueryErrorMessage(dataObject);
+    errorData.message = message;
+    errorData.Error = {
+      Type: errorData.Type,
+      Code: errorData.Code,
+      Message: message
+    };
+    const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, this.mixin.findQueryCompatibleError);
+    const ns = NormalizedSchema.of(errorSchema);
+    const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
+    const exception = new ErrorCtor({});
+    const output = {
+      Type: errorData.Error.Type,
+      Code: errorData.Error.Code,
+      Error: errorData.Error
+    };
+    for (const [name, member] of ns.structIterator()) {
+      const target = member.getMergedTraits().xmlName ?? name;
+      const value = errorData[target] ?? dataObject[target];
+      output[name] = this.deserializer.readSchema(member, value);
+    }
+    throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
+      $fault: ns.getMergedTraits().error,
+      message
+    }, output), dataObject);
+  }
+  loadQueryErrorCode(output, data) {
+    const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code;
+    if (code !== void 0) {
+      return code;
+    }
+    if (output.statusCode == 404) {
+      return "NotFound";
+    }
+  }
+  loadQueryError(data) {
+    return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error;
+  }
+  loadQueryErrorMessage(data) {
+    const errorData = this.loadQueryError(data);
+    return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown";
+  }
+  getDefaultContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+};
+
+export {
+  AwsSdkSigV4Signer,
+  AwsSdkSigV4ASigner,
+  NODE_AUTH_SCHEME_PREFERENCE_OPTIONS,
+  resolveAwsSdkSigV4AConfig,
+  NODE_SIGV4A_CONFIG_OPTIONS,
+  resolveAwsSdkSigV4Config,
+  AwsRestJsonProtocol,
+  AwsQueryProtocol
+};