@aws-sdk/client-cloudsearch 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,4164 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudSearchServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./CloudSearchClient"), exports);
-tslib_1.__exportStar(require("./CloudSearch"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var CloudSearchServiceException_1 = require("./models/CloudSearchServiceException");
-Object.defineProperty(exports, "CloudSearchServiceException", { enumerable: true, get: function () { return CloudSearchServiceException_1.CloudSearchServiceException; } });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AlgorithmicStemming: () => AlgorithmicStemming,
+  AnalysisSchemeLanguage: () => AnalysisSchemeLanguage,
+  BaseException: () => BaseException,
+  BuildSuggestersCommand: () => BuildSuggestersCommand,
+  CloudSearch: () => CloudSearch,
+  CloudSearchClient: () => CloudSearchClient,
+  CloudSearchServiceException: () => CloudSearchServiceException,
+  CreateDomainCommand: () => CreateDomainCommand,
+  DefineAnalysisSchemeCommand: () => DefineAnalysisSchemeCommand,
+  DefineExpressionCommand: () => DefineExpressionCommand,
+  DefineIndexFieldCommand: () => DefineIndexFieldCommand,
+  DefineSuggesterCommand: () => DefineSuggesterCommand,
+  DeleteAnalysisSchemeCommand: () => DeleteAnalysisSchemeCommand,
+  DeleteDomainCommand: () => DeleteDomainCommand,
+  DeleteExpressionCommand: () => DeleteExpressionCommand,
+  DeleteIndexFieldCommand: () => DeleteIndexFieldCommand,
+  DeleteSuggesterCommand: () => DeleteSuggesterCommand,
+  DescribeAnalysisSchemesCommand: () => DescribeAnalysisSchemesCommand,
+  DescribeAvailabilityOptionsCommand: () => DescribeAvailabilityOptionsCommand,
+  DescribeDomainEndpointOptionsCommand: () => DescribeDomainEndpointOptionsCommand,
+  DescribeDomainsCommand: () => DescribeDomainsCommand,
+  DescribeExpressionsCommand: () => DescribeExpressionsCommand,
+  DescribeIndexFieldsCommand: () => DescribeIndexFieldsCommand,
+  DescribeScalingParametersCommand: () => DescribeScalingParametersCommand,
+  DescribeServiceAccessPoliciesCommand: () => DescribeServiceAccessPoliciesCommand,
+  DescribeSuggestersCommand: () => DescribeSuggestersCommand,
+  DisabledOperationException: () => DisabledOperationException,
+  IndexDocumentsCommand: () => IndexDocumentsCommand,
+  IndexFieldType: () => IndexFieldType,
+  InternalException: () => InternalException,
+  InvalidTypeException: () => InvalidTypeException,
+  LimitExceededException: () => LimitExceededException,
+  ListDomainNamesCommand: () => ListDomainNamesCommand,
+  OptionState: () => OptionState,
+  PartitionInstanceType: () => PartitionInstanceType,
+  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SuggesterFuzzyMatching: () => SuggesterFuzzyMatching,
+  TLSSecurityPolicy: () => TLSSecurityPolicy,
+  UpdateAvailabilityOptionsCommand: () => UpdateAvailabilityOptionsCommand,
+  UpdateDomainEndpointOptionsCommand: () => UpdateDomainEndpointOptionsCommand,
+  UpdateScalingParametersCommand: () => UpdateScalingParametersCommand,
+  UpdateServiceAccessPoliciesCommand: () => UpdateServiceAccessPoliciesCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/CloudSearchClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "cloudsearch"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/CloudSearchClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/CloudSearchClient.ts
+var _CloudSearchClient = class _CloudSearchClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_CloudSearchClient, "CloudSearchClient");
+var CloudSearchClient = _CloudSearchClient;
+
+// src/CloudSearch.ts
+
+
+// src/commands/BuildSuggestersCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_query.ts
+
+
+var import_fast_xml_parser = require("fast-xml-parser");
+
+// src/models/CloudSearchServiceException.ts
+
+var _CloudSearchServiceException = class _CloudSearchServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _CloudSearchServiceException.prototype);
+  }
+};
+__name(_CloudSearchServiceException, "CloudSearchServiceException");
+var CloudSearchServiceException = _CloudSearchServiceException;
+
+// src/models/models_0.ts
+var _BaseException = class _BaseException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BaseException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BaseException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BaseException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_BaseException, "BaseException");
+var BaseException = _BaseException;
+var _InternalException = class _InternalException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalException, "InternalException");
+var InternalException = _InternalException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ValidationException = class _ValidationException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _LimitExceededException = class _LimitExceededException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
+var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
+var AlgorithmicStemming = {
+  full: "full",
+  light: "light",
+  minimal: "minimal",
+  none: "none"
+};
+var AnalysisSchemeLanguage = {
+  ar: "ar",
+  bg: "bg",
+  ca: "ca",
+  cs: "cs",
+  da: "da",
+  de: "de",
+  el: "el",
+  en: "en",
+  es: "es",
+  eu: "eu",
+  fa: "fa",
+  fi: "fi",
+  fr: "fr",
+  ga: "ga",
+  gl: "gl",
+  he: "he",
+  hi: "hi",
+  hu: "hu",
+  hy: "hy",
+  id: "id",
+  it: "it",
+  ja: "ja",
+  ko: "ko",
+  lv: "lv",
+  mul: "mul",
+  nl: "nl",
+  no: "no",
+  pt: "pt",
+  ro: "ro",
+  ru: "ru",
+  sv: "sv",
+  th: "th",
+  tr: "tr",
+  zh_Hans: "zh-Hans",
+  zh_Hant: "zh-Hant"
+};
+var OptionState = {
+  Active: "Active",
+  FailedToValidate: "FailedToValidate",
+  Processing: "Processing",
+  RequiresIndexDocuments: "RequiresIndexDocuments"
+};
+var _InvalidTypeException = class _InvalidTypeException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTypeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTypeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTypeException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidTypeException, "InvalidTypeException");
+var InvalidTypeException = _InvalidTypeException;
+var IndexFieldType = {
+  date: "date",
+  date_array: "date-array",
+  double: "double",
+  double_array: "double-array",
+  int: "int",
+  int_array: "int-array",
+  latlon: "latlon",
+  literal: "literal",
+  literal_array: "literal-array",
+  text: "text",
+  text_array: "text-array"
+};
+var SuggesterFuzzyMatching = {
+  high: "high",
+  low: "low",
+  none: "none"
+};
+var _DisabledOperationException = class _DisabledOperationException extends CloudSearchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DisabledOperationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DisabledOperationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DisabledOperationException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_DisabledOperationException, "DisabledOperationException");
+var DisabledOperationException = _DisabledOperationException;
+var TLSSecurityPolicy = {
+  POLICY_MIN_TLS_1_0_2019_07: "Policy-Min-TLS-1-0-2019-07",
+  POLICY_MIN_TLS_1_2_2019_07: "Policy-Min-TLS-1-2-2019-07"
+};
+var PartitionInstanceType = {
+  search_2xlarge: "search.2xlarge",
+  search_large: "search.large",
+  search_m1_large: "search.m1.large",
+  search_m1_small: "search.m1.small",
+  search_m2_2xlarge: "search.m2.2xlarge",
+  search_m2_xlarge: "search.m2.xlarge",
+  search_m3_2xlarge: "search.m3.2xlarge",
+  search_m3_large: "search.m3.large",
+  search_m3_medium: "search.m3.medium",
+  search_m3_xlarge: "search.m3.xlarge",
+  search_medium: "search.medium",
+  search_previousgeneration_2xlarge: "search.previousgeneration.2xlarge",
+  search_previousgeneration_large: "search.previousgeneration.large",
+  search_previousgeneration_small: "search.previousgeneration.small",
+  search_previousgeneration_xlarge: "search.previousgeneration.xlarge",
+  search_small: "search.small",
+  search_xlarge: "search.xlarge"
+};
+
+// src/protocols/Aws_query.ts
+var se_BuildSuggestersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_BuildSuggestersRequest(input, context),
+    [_A]: _BS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_BuildSuggestersCommand");
+var se_CreateDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateDomainRequest(input, context),
+    [_A]: _CD,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDomainCommand");
+var se_DefineAnalysisSchemeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DefineAnalysisSchemeRequest(input, context),
+    [_A]: _DAS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DefineAnalysisSchemeCommand");
+var se_DefineExpressionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DefineExpressionRequest(input, context),
+    [_A]: _DE,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DefineExpressionCommand");
+var se_DefineIndexFieldCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DefineIndexFieldRequest(input, context),
+    [_A]: _DIF,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DefineIndexFieldCommand");
+var se_DefineSuggesterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DefineSuggesterRequest(input, context),
+    [_A]: _DS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DefineSuggesterCommand");
+var se_DeleteAnalysisSchemeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteAnalysisSchemeRequest(input, context),
+    [_A]: _DASe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAnalysisSchemeCommand");
+var se_DeleteDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteDomainRequest(input, context),
+    [_A]: _DD,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteDomainCommand");
+var se_DeleteExpressionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteExpressionRequest(input, context),
+    [_A]: _DEe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteExpressionCommand");
+var se_DeleteIndexFieldCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteIndexFieldRequest(input, context),
+    [_A]: _DIFe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteIndexFieldCommand");
+var se_DeleteSuggesterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteSuggesterRequest(input, context),
+    [_A]: _DSe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteSuggesterCommand");
+var se_DescribeAnalysisSchemesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeAnalysisSchemesRequest(input, context),
+    [_A]: _DASes,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAnalysisSchemesCommand");
+var se_DescribeAvailabilityOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeAvailabilityOptionsRequest(input, context),
+    [_A]: _DAO,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAvailabilityOptionsCommand");
+var se_DescribeDomainEndpointOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeDomainEndpointOptionsRequest(input, context),
+    [_A]: _DDEO,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDomainEndpointOptionsCommand");
+var se_DescribeDomainsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeDomainsRequest(input, context),
+    [_A]: _DDe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDomainsCommand");
+var se_DescribeExpressionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeExpressionsRequest(input, context),
+    [_A]: _DEes,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeExpressionsCommand");
+var se_DescribeIndexFieldsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeIndexFieldsRequest(input, context),
+    [_A]: _DIFes,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeIndexFieldsCommand");
+var se_DescribeScalingParametersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeScalingParametersRequest(input, context),
+    [_A]: _DSP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeScalingParametersCommand");
+var se_DescribeServiceAccessPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeServiceAccessPoliciesRequest(input, context),
+    [_A]: _DSAP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeServiceAccessPoliciesCommand");
+var se_DescribeSuggestersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeSuggestersRequest(input, context),
+    [_A]: _DSes,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeSuggestersCommand");
+var se_IndexDocumentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_IndexDocumentsRequest(input, context),
+    [_A]: _ID,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_IndexDocumentsCommand");
+var se_ListDomainNamesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  const body = buildFormUrlencodedString({
+    [_A]: _LDN,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListDomainNamesCommand");
+var se_UpdateAvailabilityOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_UpdateAvailabilityOptionsRequest(input, context),
+    [_A]: _UAO,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateAvailabilityOptionsCommand");
+var se_UpdateDomainEndpointOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_UpdateDomainEndpointOptionsRequest(input, context),
+    [_A]: _UDEO,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateDomainEndpointOptionsCommand");
+var se_UpdateScalingParametersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_UpdateScalingParametersRequest(input, context),
+    [_A]: _USP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateScalingParametersCommand");
+var se_UpdateServiceAccessPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_UpdateServiceAccessPoliciesRequest(input, context),
+    [_A]: _USAP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateServiceAccessPoliciesCommand");
+var de_BuildSuggestersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_BuildSuggestersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_BuildSuggestersResponse(data.BuildSuggestersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_BuildSuggestersCommand");
+var de_BuildSuggestersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_BuildSuggestersCommandError");
+var de_CreateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDomainCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateDomainResponse(data.CreateDomainResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDomainCommand");
+var de_CreateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExists":
+    case "com.amazonaws.cloudsearch#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateDomainCommandError");
+var de_DefineAnalysisSchemeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DefineAnalysisSchemeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DefineAnalysisSchemeResponse(data.DefineAnalysisSchemeResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DefineAnalysisSchemeCommand");
+var de_DefineAnalysisSchemeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DefineAnalysisSchemeCommandError");
+var de_DefineExpressionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DefineExpressionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DefineExpressionResponse(data.DefineExpressionResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DefineExpressionCommand");
+var de_DefineExpressionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DefineExpressionCommandError");
+var de_DefineIndexFieldCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DefineIndexFieldCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DefineIndexFieldResponse(data.DefineIndexFieldResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DefineIndexFieldCommand");
+var de_DefineIndexFieldCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DefineIndexFieldCommandError");
+var de_DefineSuggesterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DefineSuggesterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DefineSuggesterResponse(data.DefineSuggesterResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DefineSuggesterCommand");
+var de_DefineSuggesterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DefineSuggesterCommandError");
+var de_DeleteAnalysisSchemeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAnalysisSchemeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteAnalysisSchemeResponse(data.DeleteAnalysisSchemeResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAnalysisSchemeCommand");
+var de_DeleteAnalysisSchemeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteAnalysisSchemeCommandError");
+var de_DeleteDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteDomainCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteDomainResponse(data.DeleteDomainResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteDomainCommand");
+var de_DeleteDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteDomainCommandError");
+var de_DeleteExpressionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteExpressionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteExpressionResponse(data.DeleteExpressionResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteExpressionCommand");
+var de_DeleteExpressionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteExpressionCommandError");
+var de_DeleteIndexFieldCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteIndexFieldCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteIndexFieldResponse(data.DeleteIndexFieldResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteIndexFieldCommand");
+var de_DeleteIndexFieldCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteIndexFieldCommandError");
+var de_DeleteSuggesterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteSuggesterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteSuggesterResponse(data.DeleteSuggesterResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteSuggesterCommand");
+var de_DeleteSuggesterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteSuggesterCommandError");
+var de_DescribeAnalysisSchemesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAnalysisSchemesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAnalysisSchemesResponse(data.DescribeAnalysisSchemesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAnalysisSchemesCommand");
+var de_DescribeAnalysisSchemesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeAnalysisSchemesCommandError");
+var de_DescribeAvailabilityOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAvailabilityOptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAvailabilityOptionsResponse(data.DescribeAvailabilityOptionsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAvailabilityOptionsCommand");
+var de_DescribeAvailabilityOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "DisabledAction":
+    case "com.amazonaws.cloudsearch#DisabledOperationException":
+      throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeAvailabilityOptionsCommandError");
+var de_DescribeDomainEndpointOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDomainEndpointOptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeDomainEndpointOptionsResponse(data.DescribeDomainEndpointOptionsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDomainEndpointOptionsCommand");
+var de_DescribeDomainEndpointOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "DisabledAction":
+    case "com.amazonaws.cloudsearch#DisabledOperationException":
+      throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeDomainEndpointOptionsCommandError");
+var de_DescribeDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDomainsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeDomainsResponse(data.DescribeDomainsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDomainsCommand");
+var de_DescribeDomainsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeDomainsCommandError");
+var de_DescribeExpressionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeExpressionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeExpressionsResponse(data.DescribeExpressionsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeExpressionsCommand");
+var de_DescribeExpressionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeExpressionsCommandError");
+var de_DescribeIndexFieldsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeIndexFieldsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeIndexFieldsResponse(data.DescribeIndexFieldsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeIndexFieldsCommand");
+var de_DescribeIndexFieldsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeIndexFieldsCommandError");
+var de_DescribeScalingParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeScalingParametersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeScalingParametersResponse(data.DescribeScalingParametersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeScalingParametersCommand");
+var de_DescribeScalingParametersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeScalingParametersCommandError");
+var de_DescribeServiceAccessPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeServiceAccessPoliciesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeServiceAccessPoliciesResponse(data.DescribeServiceAccessPoliciesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeServiceAccessPoliciesCommand");
+var de_DescribeServiceAccessPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeServiceAccessPoliciesCommandError");
+var de_DescribeSuggestersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeSuggestersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeSuggestersResponse(data.DescribeSuggestersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeSuggestersCommand");
+var de_DescribeSuggestersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeSuggestersCommandError");
+var de_IndexDocumentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_IndexDocumentsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_IndexDocumentsResponse(data.IndexDocumentsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_IndexDocumentsCommand");
+var de_IndexDocumentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_IndexDocumentsCommandError");
+var de_ListDomainNamesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListDomainNamesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListDomainNamesResponse(data.ListDomainNamesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListDomainNamesCommand");
+var de_ListDomainNamesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_ListDomainNamesCommandError");
+var de_UpdateAvailabilityOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateAvailabilityOptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateAvailabilityOptionsResponse(data.UpdateAvailabilityOptionsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateAvailabilityOptionsCommand");
+var de_UpdateAvailabilityOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "DisabledAction":
+    case "com.amazonaws.cloudsearch#DisabledOperationException":
+      throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_UpdateAvailabilityOptionsCommandError");
+var de_UpdateDomainEndpointOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateDomainEndpointOptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateDomainEndpointOptionsResponse(data.UpdateDomainEndpointOptionsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateDomainEndpointOptionsCommand");
+var de_UpdateDomainEndpointOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "DisabledAction":
+    case "com.amazonaws.cloudsearch#DisabledOperationException":
+      throw await de_DisabledOperationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_UpdateDomainEndpointOptionsCommandError");
+var de_UpdateScalingParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateScalingParametersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateScalingParametersResponse(data.UpdateScalingParametersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateScalingParametersCommand");
+var de_UpdateScalingParametersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_UpdateScalingParametersCommandError");
+var de_UpdateServiceAccessPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateServiceAccessPoliciesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateServiceAccessPoliciesResponse(data.UpdateServiceAccessPoliciesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateServiceAccessPoliciesCommand");
+var de_UpdateServiceAccessPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BaseException":
+    case "com.amazonaws.cloudsearch#BaseException":
+      throw await de_BaseExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudsearch#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidType":
+    case "com.amazonaws.cloudsearch#InvalidTypeException":
+      throw await de_InvalidTypeExceptionRes(parsedOutput, context);
+    case "LimitExceeded":
+    case "com.amazonaws.cloudsearch#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.cloudsearch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.cloudsearch#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_UpdateServiceAccessPoliciesCommandError");
+var de_BaseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_BaseException(body.Error, context);
+  const exception = new BaseException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_BaseExceptionRes");
+var de_DisabledOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DisabledOperationException(body.Error, context);
+  const exception = new DisabledOperationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DisabledOperationExceptionRes");
+var de_InternalExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InternalException(body.Error, context);
+  const exception = new InternalException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalExceptionRes");
+var de_InvalidTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidTypeException(body.Error, context);
+  const exception = new InvalidTypeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTypeExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_LimitExceededException(body.Error, context);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_ResourceAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_ResourceAlreadyExistsException(body.Error, context);
+  const exception = new ResourceAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceAlreadyExistsExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_ResourceNotFoundException(body.Error, context);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_ValidationException(body.Error, context);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var se_AnalysisOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_S] != null) {
+    entries[_S] = input[_S];
+  }
+  if (input[_St] != null) {
+    entries[_St] = input[_St];
+  }
+  if (input[_SD] != null) {
+    entries[_SD] = input[_SD];
+  }
+  if (input[_JTD] != null) {
+    entries[_JTD] = input[_JTD];
+  }
+  if (input[_AS] != null) {
+    entries[_AS] = input[_AS];
+  }
+  return entries;
+}, "se_AnalysisOptions");
+var se_AnalysisScheme = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_ASN] != null) {
+    entries[_ASN] = input[_ASN];
+  }
+  if (input[_ASL] != null) {
+    entries[_ASL] = input[_ASL];
+  }
+  if (input[_AO] != null) {
+    const memberEntries = se_AnalysisOptions(input[_AO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AnalysisOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_AnalysisScheme");
+var se_BuildSuggestersRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  return entries;
+}, "se_BuildSuggestersRequest");
+var se_CreateDomainRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  return entries;
+}, "se_CreateDomainRequest");
+var se_DateArrayOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SF] != null) {
+    entries[_SF] = input[_SF];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  return entries;
+}, "se_DateArrayOptions");
+var se_DateOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  return entries;
+}, "se_DateOptions");
+var se_DefineAnalysisSchemeRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_ASn] != null) {
+    const memberEntries = se_AnalysisScheme(input[_ASn], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AnalysisScheme.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DefineAnalysisSchemeRequest");
+var se_DefineExpressionRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_E] != null) {
+    const memberEntries = se_Expression(input[_E], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Expression.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DefineExpressionRequest");
+var se_DefineIndexFieldRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_IF] != null) {
+    const memberEntries = se_IndexField(input[_IF], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `IndexField.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DefineIndexFieldRequest");
+var se_DefineSuggesterRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_Su] != null) {
+    const memberEntries = se_Suggester(input[_Su], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Suggester.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DefineSuggesterRequest");
+var se_DeleteAnalysisSchemeRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_ASN] != null) {
+    entries[_ASN] = input[_ASN];
+  }
+  return entries;
+}, "se_DeleteAnalysisSchemeRequest");
+var se_DeleteDomainRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  return entries;
+}, "se_DeleteDomainRequest");
+var se_DeleteExpressionRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_EN] != null) {
+    entries[_EN] = input[_EN];
+  }
+  return entries;
+}, "se_DeleteExpressionRequest");
+var se_DeleteIndexFieldRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_IFN] != null) {
+    entries[_IFN] = input[_IFN];
+  }
+  return entries;
+}, "se_DeleteIndexFieldRequest");
+var se_DeleteSuggesterRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_SN] != null) {
+    entries[_SN] = input[_SN];
+  }
+  return entries;
+}, "se_DeleteSuggesterRequest");
+var se_DescribeAnalysisSchemesRequest = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_ASNn] != null) {
+    const memberEntries = se_StandardNameList(input[_ASNn], context);
+    if (((_a = input[_ASNn]) == null ? void 0 : _a.length) === 0) {
+      entries.AnalysisSchemeNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AnalysisSchemeNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeAnalysisSchemesRequest");
+var se_DescribeAvailabilityOptionsRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeAvailabilityOptionsRequest");
+var se_DescribeDomainEndpointOptionsRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeDomainEndpointOptionsRequest");
+var se_DescribeDomainsRequest = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_DNo] != null) {
+    const memberEntries = se_DomainNameList(input[_DNo], context);
+    if (((_a = input[_DNo]) == null ? void 0 : _a.length) === 0) {
+      entries.DomainNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DomainNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DescribeDomainsRequest");
+var se_DescribeExpressionsRequest = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_ENx] != null) {
+    const memberEntries = se_StandardNameList(input[_ENx], context);
+    if (((_a = input[_ENx]) == null ? void 0 : _a.length) === 0) {
+      entries.ExpressionNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `ExpressionNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeExpressionsRequest");
+var se_DescribeIndexFieldsRequest = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_FN] != null) {
+    const memberEntries = se_DynamicFieldNameList(input[_FN], context);
+    if (((_a = input[_FN]) == null ? void 0 : _a.length) === 0) {
+      entries.FieldNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `FieldNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeIndexFieldsRequest");
+var se_DescribeScalingParametersRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  return entries;
+}, "se_DescribeScalingParametersRequest");
+var se_DescribeServiceAccessPoliciesRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeServiceAccessPoliciesRequest");
+var se_DescribeSuggestersRequest = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_SNu] != null) {
+    const memberEntries = se_StandardNameList(input[_SNu], context);
+    if (((_a = input[_SNu]) == null ? void 0 : _a.length) === 0) {
+      entries.SuggesterNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `SuggesterNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_D] != null) {
+    entries[_D] = input[_D];
+  }
+  return entries;
+}, "se_DescribeSuggestersRequest");
+var se_DocumentSuggesterOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FM] != null) {
+    entries[_FM] = input[_FM];
+  }
+  if (input[_SEor] != null) {
+    entries[_SEor] = input[_SEor];
+  }
+  return entries;
+}, "se_DocumentSuggesterOptions");
+var se_DomainEndpointOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_EHTTPS] != null) {
+    entries[_EHTTPS] = input[_EHTTPS];
+  }
+  if (input[_TLSSP] != null) {
+    entries[_TLSSP] = input[_TLSSP];
+  }
+  return entries;
+}, "se_DomainEndpointOptions");
+var se_DomainNameList = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_DomainNameList");
+var se_DoubleArrayOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = (0, import_smithy_client.serializeFloat)(input[_DV]);
+  }
+  if (input[_SF] != null) {
+    entries[_SF] = input[_SF];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  return entries;
+}, "se_DoubleArrayOptions");
+var se_DoubleOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = (0, import_smithy_client.serializeFloat)(input[_DV]);
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  return entries;
+}, "se_DoubleOptions");
+var se_DynamicFieldNameList = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_DynamicFieldNameList");
+var se_Expression = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_EN] != null) {
+    entries[_EN] = input[_EN];
+  }
+  if (input[_EV] != null) {
+    entries[_EV] = input[_EV];
+  }
+  return entries;
+}, "se_Expression");
+var se_IndexDocumentsRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  return entries;
+}, "se_IndexDocumentsRequest");
+var se_IndexField = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_IFN] != null) {
+    entries[_IFN] = input[_IFN];
+  }
+  if (input[_IFT] != null) {
+    entries[_IFT] = input[_IFT];
+  }
+  if (input[_IO] != null) {
+    const memberEntries = se_IntOptions(input[_IO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `IntOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_DO] != null) {
+    const memberEntries = se_DoubleOptions(input[_DO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DoubleOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_LO] != null) {
+    const memberEntries = se_LiteralOptions(input[_LO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LiteralOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_TO] != null) {
+    const memberEntries = se_TextOptions(input[_TO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `TextOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_DOa] != null) {
+    const memberEntries = se_DateOptions(input[_DOa], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DateOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_LLO] != null) {
+    const memberEntries = se_LatLonOptions(input[_LLO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LatLonOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_IAO] != null) {
+    const memberEntries = se_IntArrayOptions(input[_IAO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `IntArrayOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_DAOo] != null) {
+    const memberEntries = se_DoubleArrayOptions(input[_DAOo], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DoubleArrayOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_LAO] != null) {
+    const memberEntries = se_LiteralArrayOptions(input[_LAO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LiteralArrayOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_TAO] != null) {
+    const memberEntries = se_TextArrayOptions(input[_TAO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `TextArrayOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_DAOa] != null) {
+    const memberEntries = se_DateArrayOptions(input[_DAOa], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DateArrayOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_IndexField");
+var se_IntArrayOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SF] != null) {
+    entries[_SF] = input[_SF];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  return entries;
+}, "se_IntArrayOptions");
+var se_IntOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  return entries;
+}, "se_IntOptions");
+var se_LatLonOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  return entries;
+}, "se_LatLonOptions");
+var se_LiteralArrayOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SF] != null) {
+    entries[_SF] = input[_SF];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  return entries;
+}, "se_LiteralArrayOptions");
+var se_LiteralOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_FE] != null) {
+    entries[_FE] = input[_FE];
+  }
+  if (input[_SE] != null) {
+    entries[_SE] = input[_SE];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  return entries;
+}, "se_LiteralOptions");
+var se_ScalingParameters = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DIT] != null) {
+    entries[_DIT] = input[_DIT];
+  }
+  if (input[_DRC] != null) {
+    entries[_DRC] = input[_DRC];
+  }
+  if (input[_DPC] != null) {
+    entries[_DPC] = input[_DPC];
+  }
+  return entries;
+}, "se_ScalingParameters");
+var se_StandardNameList = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_StandardNameList");
+var se_Suggester = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_SN] != null) {
+    entries[_SN] = input[_SN];
+  }
+  if (input[_DSO] != null) {
+    const memberEntries = se_DocumentSuggesterOptions(input[_DSO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DocumentSuggesterOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_Suggester");
+var se_TextArrayOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SF] != null) {
+    entries[_SF] = input[_SF];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_HE] != null) {
+    entries[_HE] = input[_HE];
+  }
+  if (input[_ASn] != null) {
+    entries[_ASn] = input[_ASn];
+  }
+  return entries;
+}, "se_TextArrayOptions");
+var se_TextOptions = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DV] != null) {
+    entries[_DV] = input[_DV];
+  }
+  if (input[_SFo] != null) {
+    entries[_SFo] = input[_SFo];
+  }
+  if (input[_RE] != null) {
+    entries[_RE] = input[_RE];
+  }
+  if (input[_SEo] != null) {
+    entries[_SEo] = input[_SEo];
+  }
+  if (input[_HE] != null) {
+    entries[_HE] = input[_HE];
+  }
+  if (input[_ASn] != null) {
+    entries[_ASn] = input[_ASn];
+  }
+  return entries;
+}, "se_TextOptions");
+var se_UpdateAvailabilityOptionsRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_MAZ] != null) {
+    entries[_MAZ] = input[_MAZ];
+  }
+  return entries;
+}, "se_UpdateAvailabilityOptionsRequest");
+var se_UpdateDomainEndpointOptionsRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_DEO] != null) {
+    const memberEntries = se_DomainEndpointOptions(input[_DEO], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `DomainEndpointOptions.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_UpdateDomainEndpointOptionsRequest");
+var se_UpdateScalingParametersRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_SP] != null) {
+    const memberEntries = se_ScalingParameters(input[_SP], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `ScalingParameters.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_UpdateScalingParametersRequest");
+var se_UpdateServiceAccessPoliciesRequest = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_DN] != null) {
+    entries[_DN] = input[_DN];
+  }
+  if (input[_AP] != null) {
+    entries[_AP] = input[_AP];
+  }
+  return entries;
+}, "se_UpdateServiceAccessPoliciesRequest");
+var de_AccessPoliciesStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = (0, import_smithy_client.expectString)(output[_O]);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_AccessPoliciesStatus");
+var de_AnalysisOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_S] != null) {
+    contents[_S] = (0, import_smithy_client.expectString)(output[_S]);
+  }
+  if (output[_St] != null) {
+    contents[_St] = (0, import_smithy_client.expectString)(output[_St]);
+  }
+  if (output[_SD] != null) {
+    contents[_SD] = (0, import_smithy_client.expectString)(output[_SD]);
+  }
+  if (output[_JTD] != null) {
+    contents[_JTD] = (0, import_smithy_client.expectString)(output[_JTD]);
+  }
+  if (output[_AS] != null) {
+    contents[_AS] = (0, import_smithy_client.expectString)(output[_AS]);
+  }
+  return contents;
+}, "de_AnalysisOptions");
+var de_AnalysisScheme = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_ASN] != null) {
+    contents[_ASN] = (0, import_smithy_client.expectString)(output[_ASN]);
+  }
+  if (output[_ASL] != null) {
+    contents[_ASL] = (0, import_smithy_client.expectString)(output[_ASL]);
+  }
+  if (output[_AO] != null) {
+    contents[_AO] = de_AnalysisOptions(output[_AO], context);
+  }
+  return contents;
+}, "de_AnalysisScheme");
+var de_AnalysisSchemeStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_AnalysisScheme(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_AnalysisSchemeStatus");
+var de_AnalysisSchemeStatusList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_AnalysisSchemeStatus(entry, context);
+  });
+}, "de_AnalysisSchemeStatusList");
+var de_AvailabilityOptionsStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = (0, import_smithy_client.parseBoolean)(output[_O]);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_AvailabilityOptionsStatus");
+var de_BaseException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_BaseException");
+var de_BuildSuggestersResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.FieldNames === "") {
+    contents[_FN] = [];
+  } else if (output[_FN] != null && output[_FN][_m] != null) {
+    contents[_FN] = de_FieldNameList((0, import_smithy_client.getArrayIfSingleItem)(output[_FN][_m]), context);
+  }
+  return contents;
+}, "de_BuildSuggestersResponse");
+var de_CreateDomainResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DSo] != null) {
+    contents[_DSo] = de_DomainStatus(output[_DSo], context);
+  }
+  return contents;
+}, "de_CreateDomainResponse");
+var de_DateArrayOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SF] != null) {
+    contents[_SF] = (0, import_smithy_client.expectString)(output[_SF]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  return contents;
+}, "de_DateArrayOptions");
+var de_DateOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  return contents;
+}, "de_DateOptions");
+var de_DefineAnalysisSchemeResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_ASn] != null) {
+    contents[_ASn] = de_AnalysisSchemeStatus(output[_ASn], context);
+  }
+  return contents;
+}, "de_DefineAnalysisSchemeResponse");
+var de_DefineExpressionResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_E] != null) {
+    contents[_E] = de_ExpressionStatus(output[_E], context);
+  }
+  return contents;
+}, "de_DefineExpressionResponse");
+var de_DefineIndexFieldResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_IF] != null) {
+    contents[_IF] = de_IndexFieldStatus(output[_IF], context);
+  }
+  return contents;
+}, "de_DefineIndexFieldResponse");
+var de_DefineSuggesterResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Su] != null) {
+    contents[_Su] = de_SuggesterStatus(output[_Su], context);
+  }
+  return contents;
+}, "de_DefineSuggesterResponse");
+var de_DeleteAnalysisSchemeResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_ASn] != null) {
+    contents[_ASn] = de_AnalysisSchemeStatus(output[_ASn], context);
+  }
+  return contents;
+}, "de_DeleteAnalysisSchemeResponse");
+var de_DeleteDomainResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DSo] != null) {
+    contents[_DSo] = de_DomainStatus(output[_DSo], context);
+  }
+  return contents;
+}, "de_DeleteDomainResponse");
+var de_DeleteExpressionResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_E] != null) {
+    contents[_E] = de_ExpressionStatus(output[_E], context);
+  }
+  return contents;
+}, "de_DeleteExpressionResponse");
+var de_DeleteIndexFieldResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_IF] != null) {
+    contents[_IF] = de_IndexFieldStatus(output[_IF], context);
+  }
+  return contents;
+}, "de_DeleteIndexFieldResponse");
+var de_DeleteSuggesterResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Su] != null) {
+    contents[_Su] = de_SuggesterStatus(output[_Su], context);
+  }
+  return contents;
+}, "de_DeleteSuggesterResponse");
+var de_DescribeAnalysisSchemesResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.AnalysisSchemes === "") {
+    contents[_ASna] = [];
+  } else if (output[_ASna] != null && output[_ASna][_m] != null) {
+    contents[_ASna] = de_AnalysisSchemeStatusList((0, import_smithy_client.getArrayIfSingleItem)(output[_ASna][_m]), context);
+  }
+  return contents;
+}, "de_DescribeAnalysisSchemesResponse");
+var de_DescribeAvailabilityOptionsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AOv] != null) {
+    contents[_AOv] = de_AvailabilityOptionsStatus(output[_AOv], context);
+  }
+  return contents;
+}, "de_DescribeAvailabilityOptionsResponse");
+var de_DescribeDomainEndpointOptionsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DEO] != null) {
+    contents[_DEO] = de_DomainEndpointOptionsStatus(output[_DEO], context);
+  }
+  return contents;
+}, "de_DescribeDomainEndpointOptionsResponse");
+var de_DescribeDomainsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.DomainStatusList === "") {
+    contents[_DSL] = [];
+  } else if (output[_DSL] != null && output[_DSL][_m] != null) {
+    contents[_DSL] = de_DomainStatusList((0, import_smithy_client.getArrayIfSingleItem)(output[_DSL][_m]), context);
+  }
+  return contents;
+}, "de_DescribeDomainsResponse");
+var de_DescribeExpressionsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Expressions === "") {
+    contents[_Ex] = [];
+  } else if (output[_Ex] != null && output[_Ex][_m] != null) {
+    contents[_Ex] = de_ExpressionStatusList((0, import_smithy_client.getArrayIfSingleItem)(output[_Ex][_m]), context);
+  }
+  return contents;
+}, "de_DescribeExpressionsResponse");
+var de_DescribeIndexFieldsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.IndexFields === "") {
+    contents[_IFn] = [];
+  } else if (output[_IFn] != null && output[_IFn][_m] != null) {
+    contents[_IFn] = de_IndexFieldStatusList((0, import_smithy_client.getArrayIfSingleItem)(output[_IFn][_m]), context);
+  }
+  return contents;
+}, "de_DescribeIndexFieldsResponse");
+var de_DescribeScalingParametersResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_SP] != null) {
+    contents[_SP] = de_ScalingParametersStatus(output[_SP], context);
+  }
+  return contents;
+}, "de_DescribeScalingParametersResponse");
+var de_DescribeServiceAccessPoliciesResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AP] != null) {
+    contents[_AP] = de_AccessPoliciesStatus(output[_AP], context);
+  }
+  return contents;
+}, "de_DescribeServiceAccessPoliciesResponse");
+var de_DescribeSuggestersResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Suggesters === "") {
+    contents[_Sug] = [];
+  } else if (output[_Sug] != null && output[_Sug][_m] != null) {
+    contents[_Sug] = de_SuggesterStatusList((0, import_smithy_client.getArrayIfSingleItem)(output[_Sug][_m]), context);
+  }
+  return contents;
+}, "de_DescribeSuggestersResponse");
+var de_DisabledOperationException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_DisabledOperationException");
+var de_DocumentSuggesterOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FM] != null) {
+    contents[_FM] = (0, import_smithy_client.expectString)(output[_FM]);
+  }
+  if (output[_SEor] != null) {
+    contents[_SEor] = (0, import_smithy_client.expectString)(output[_SEor]);
+  }
+  return contents;
+}, "de_DocumentSuggesterOptions");
+var de_DomainEndpointOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_EHTTPS] != null) {
+    contents[_EHTTPS] = (0, import_smithy_client.parseBoolean)(output[_EHTTPS]);
+  }
+  if (output[_TLSSP] != null) {
+    contents[_TLSSP] = (0, import_smithy_client.expectString)(output[_TLSSP]);
+  }
+  return contents;
+}, "de_DomainEndpointOptions");
+var de_DomainEndpointOptionsStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_DomainEndpointOptions(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_DomainEndpointOptionsStatus");
+var de_DomainNameMap = /* @__PURE__ */ __name((output, context) => {
+  return output.reduce((acc, pair) => {
+    if (pair["value"] === null) {
+      return acc;
+    }
+    acc[pair["key"]] = (0, import_smithy_client.expectString)(pair["value"]);
+    return acc;
+  }, {});
+}, "de_DomainNameMap");
+var de_DomainStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DI] != null) {
+    contents[_DI] = (0, import_smithy_client.expectString)(output[_DI]);
+  }
+  if (output[_DN] != null) {
+    contents[_DN] = (0, import_smithy_client.expectString)(output[_DN]);
+  }
+  if (output[_ARN] != null) {
+    contents[_ARN] = (0, import_smithy_client.expectString)(output[_ARN]);
+  }
+  if (output[_Cr] != null) {
+    contents[_Cr] = (0, import_smithy_client.parseBoolean)(output[_Cr]);
+  }
+  if (output[_De] != null) {
+    contents[_De] = (0, import_smithy_client.parseBoolean)(output[_De]);
+  }
+  if (output[_DSoc] != null) {
+    contents[_DSoc] = de_ServiceEndpoint(output[_DSoc], context);
+  }
+  if (output[_SS] != null) {
+    contents[_SS] = de_ServiceEndpoint(output[_SS], context);
+  }
+  if (output[_RID] != null) {
+    contents[_RID] = (0, import_smithy_client.parseBoolean)(output[_RID]);
+  }
+  if (output[_P] != null) {
+    contents[_P] = (0, import_smithy_client.parseBoolean)(output[_P]);
+  }
+  if (output[_SIT] != null) {
+    contents[_SIT] = (0, import_smithy_client.expectString)(output[_SIT]);
+  }
+  if (output[_SPC] != null) {
+    contents[_SPC] = (0, import_smithy_client.strictParseInt32)(output[_SPC]);
+  }
+  if (output[_SIC] != null) {
+    contents[_SIC] = (0, import_smithy_client.strictParseInt32)(output[_SIC]);
+  }
+  if (output[_L] != null) {
+    contents[_L] = de_Limits(output[_L], context);
+  }
+  return contents;
+}, "de_DomainStatus");
+var de_DomainStatusList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_DomainStatus(entry, context);
+  });
+}, "de_DomainStatusList");
+var de_DoubleArrayOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.strictParseFloat)(output[_DV]);
+  }
+  if (output[_SF] != null) {
+    contents[_SF] = (0, import_smithy_client.expectString)(output[_SF]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  return contents;
+}, "de_DoubleArrayOptions");
+var de_DoubleOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.strictParseFloat)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  return contents;
+}, "de_DoubleOptions");
+var de_Expression = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_EN] != null) {
+    contents[_EN] = (0, import_smithy_client.expectString)(output[_EN]);
+  }
+  if (output[_EV] != null) {
+    contents[_EV] = (0, import_smithy_client.expectString)(output[_EV]);
+  }
+  return contents;
+}, "de_Expression");
+var de_ExpressionStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_Expression(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_ExpressionStatus");
+var de_ExpressionStatusList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExpressionStatus(entry, context);
+  });
+}, "de_ExpressionStatusList");
+var de_FieldNameList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.expectString)(entry);
+  });
+}, "de_FieldNameList");
+var de_IndexDocumentsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.FieldNames === "") {
+    contents[_FN] = [];
+  } else if (output[_FN] != null && output[_FN][_m] != null) {
+    contents[_FN] = de_FieldNameList((0, import_smithy_client.getArrayIfSingleItem)(output[_FN][_m]), context);
+  }
+  return contents;
+}, "de_IndexDocumentsResponse");
+var de_IndexField = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_IFN] != null) {
+    contents[_IFN] = (0, import_smithy_client.expectString)(output[_IFN]);
+  }
+  if (output[_IFT] != null) {
+    contents[_IFT] = (0, import_smithy_client.expectString)(output[_IFT]);
+  }
+  if (output[_IO] != null) {
+    contents[_IO] = de_IntOptions(output[_IO], context);
+  }
+  if (output[_DO] != null) {
+    contents[_DO] = de_DoubleOptions(output[_DO], context);
+  }
+  if (output[_LO] != null) {
+    contents[_LO] = de_LiteralOptions(output[_LO], context);
+  }
+  if (output[_TO] != null) {
+    contents[_TO] = de_TextOptions(output[_TO], context);
+  }
+  if (output[_DOa] != null) {
+    contents[_DOa] = de_DateOptions(output[_DOa], context);
+  }
+  if (output[_LLO] != null) {
+    contents[_LLO] = de_LatLonOptions(output[_LLO], context);
+  }
+  if (output[_IAO] != null) {
+    contents[_IAO] = de_IntArrayOptions(output[_IAO], context);
+  }
+  if (output[_DAOo] != null) {
+    contents[_DAOo] = de_DoubleArrayOptions(output[_DAOo], context);
+  }
+  if (output[_LAO] != null) {
+    contents[_LAO] = de_LiteralArrayOptions(output[_LAO], context);
+  }
+  if (output[_TAO] != null) {
+    contents[_TAO] = de_TextArrayOptions(output[_TAO], context);
+  }
+  if (output[_DAOa] != null) {
+    contents[_DAOa] = de_DateArrayOptions(output[_DAOa], context);
+  }
+  return contents;
+}, "de_IndexField");
+var de_IndexFieldStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_IndexField(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_IndexFieldStatus");
+var de_IndexFieldStatusList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_IndexFieldStatus(entry, context);
+  });
+}, "de_IndexFieldStatusList");
+var de_IntArrayOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.strictParseLong)(output[_DV]);
+  }
+  if (output[_SF] != null) {
+    contents[_SF] = (0, import_smithy_client.expectString)(output[_SF]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  return contents;
+}, "de_IntArrayOptions");
+var de_InternalException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_InternalException");
+var de_IntOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.strictParseLong)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  return contents;
+}, "de_IntOptions");
+var de_InvalidTypeException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_InvalidTypeException");
+var de_LatLonOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  return contents;
+}, "de_LatLonOptions");
+var de_LimitExceededException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_LimitExceededException");
+var de_Limits = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_MRC] != null) {
+    contents[_MRC] = (0, import_smithy_client.strictParseInt32)(output[_MRC]);
+  }
+  if (output[_MPC] != null) {
+    contents[_MPC] = (0, import_smithy_client.strictParseInt32)(output[_MPC]);
+  }
+  return contents;
+}, "de_Limits");
+var de_ListDomainNamesResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.DomainNames === "") {
+    contents[_DNo] = {};
+  } else if (output[_DNo] != null && output[_DNo][_e] != null) {
+    contents[_DNo] = de_DomainNameMap((0, import_smithy_client.getArrayIfSingleItem)(output[_DNo][_e]), context);
+  }
+  return contents;
+}, "de_ListDomainNamesResponse");
+var de_LiteralArrayOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SF] != null) {
+    contents[_SF] = (0, import_smithy_client.expectString)(output[_SF]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  return contents;
+}, "de_LiteralArrayOptions");
+var de_LiteralOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_FE] != null) {
+    contents[_FE] = (0, import_smithy_client.parseBoolean)(output[_FE]);
+  }
+  if (output[_SE] != null) {
+    contents[_SE] = (0, import_smithy_client.parseBoolean)(output[_SE]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  return contents;
+}, "de_LiteralOptions");
+var de_OptionStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_CDr] != null) {
+    contents[_CDr] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_CDr]));
+  }
+  if (output[_UD] != null) {
+    contents[_UD] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_UD]));
+  }
+  if (output[_UV] != null) {
+    contents[_UV] = (0, import_smithy_client.strictParseInt32)(output[_UV]);
+  }
+  if (output[_Stat] != null) {
+    contents[_Stat] = (0, import_smithy_client.expectString)(output[_Stat]);
+  }
+  if (output[_PD] != null) {
+    contents[_PD] = (0, import_smithy_client.parseBoolean)(output[_PD]);
+  }
+  return contents;
+}, "de_OptionStatus");
+var de_ResourceAlreadyExistsException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_ResourceAlreadyExistsException");
+var de_ResourceNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_ResourceNotFoundException");
+var de_ScalingParameters = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DIT] != null) {
+    contents[_DIT] = (0, import_smithy_client.expectString)(output[_DIT]);
+  }
+  if (output[_DRC] != null) {
+    contents[_DRC] = (0, import_smithy_client.strictParseInt32)(output[_DRC]);
+  }
+  if (output[_DPC] != null) {
+    contents[_DPC] = (0, import_smithy_client.strictParseInt32)(output[_DPC]);
+  }
+  return contents;
+}, "de_ScalingParameters");
+var de_ScalingParametersStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_ScalingParameters(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_ScalingParametersStatus");
+var de_ServiceEndpoint = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_En] != null) {
+    contents[_En] = (0, import_smithy_client.expectString)(output[_En]);
+  }
+  return contents;
+}, "de_ServiceEndpoint");
+var de_Suggester = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_SN] != null) {
+    contents[_SN] = (0, import_smithy_client.expectString)(output[_SN]);
+  }
+  if (output[_DSO] != null) {
+    contents[_DSO] = de_DocumentSuggesterOptions(output[_DSO], context);
+  }
+  return contents;
+}, "de_Suggester");
+var de_SuggesterStatus = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_O] != null) {
+    contents[_O] = de_Suggester(output[_O], context);
+  }
+  if (output[_Sta] != null) {
+    contents[_Sta] = de_OptionStatus(output[_Sta], context);
+  }
+  return contents;
+}, "de_SuggesterStatus");
+var de_SuggesterStatusList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_SuggesterStatus(entry, context);
+  });
+}, "de_SuggesterStatusList");
+var de_TextArrayOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SF] != null) {
+    contents[_SF] = (0, import_smithy_client.expectString)(output[_SF]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_HE] != null) {
+    contents[_HE] = (0, import_smithy_client.parseBoolean)(output[_HE]);
+  }
+  if (output[_ASn] != null) {
+    contents[_ASn] = (0, import_smithy_client.expectString)(output[_ASn]);
+  }
+  return contents;
+}, "de_TextArrayOptions");
+var de_TextOptions = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_SFo] != null) {
+    contents[_SFo] = (0, import_smithy_client.expectString)(output[_SFo]);
+  }
+  if (output[_RE] != null) {
+    contents[_RE] = (0, import_smithy_client.parseBoolean)(output[_RE]);
+  }
+  if (output[_SEo] != null) {
+    contents[_SEo] = (0, import_smithy_client.parseBoolean)(output[_SEo]);
+  }
+  if (output[_HE] != null) {
+    contents[_HE] = (0, import_smithy_client.parseBoolean)(output[_HE]);
+  }
+  if (output[_ASn] != null) {
+    contents[_ASn] = (0, import_smithy_client.expectString)(output[_ASn]);
+  }
+  return contents;
+}, "de_TextOptions");
+var de_UpdateAvailabilityOptionsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AOv] != null) {
+    contents[_AOv] = de_AvailabilityOptionsStatus(output[_AOv], context);
+  }
+  return contents;
+}, "de_UpdateAvailabilityOptionsResponse");
+var de_UpdateDomainEndpointOptionsResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DEO] != null) {
+    contents[_DEO] = de_DomainEndpointOptionsStatus(output[_DEO], context);
+  }
+  return contents;
+}, "de_UpdateDomainEndpointOptionsResponse");
+var de_UpdateScalingParametersResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_SP] != null) {
+    contents[_SP] = de_ScalingParametersStatus(output[_SP], context);
+  }
+  return contents;
+}, "de_UpdateScalingParametersResponse");
+var de_UpdateServiceAccessPoliciesResponse = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AP] != null) {
+    contents[_AP] = de_AccessPoliciesStatus(output[_AP], context);
+  }
+  return contents;
+}, "de_UpdateServiceAccessPoliciesResponse");
+var de_ValidationException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  if (output[_M] != null) {
+    contents[_M] = (0, import_smithy_client.expectString)(output[_M]);
+  }
+  return contents;
+}, "de_ValidationException");
+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");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(CloudSearchServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+var SHARED_HEADERS = {
+  "content-type": "application/x-www-form-urlencoded"
+};
+var _ = "2013-01-01";
+var _A = "Action";
+var _AO = "AnalysisOptions";
+var _AOv = "AvailabilityOptions";
+var _AP = "AccessPolicies";
+var _ARN = "ARN";
+var _AS = "AlgorithmicStemming";
+var _ASL = "AnalysisSchemeLanguage";
+var _ASN = "AnalysisSchemeName";
+var _ASNn = "AnalysisSchemeNames";
+var _ASn = "AnalysisScheme";
+var _ASna = "AnalysisSchemes";
+var _BS = "BuildSuggesters";
+var _C = "Code";
+var _CD = "CreateDomain";
+var _CDr = "CreationDate";
+var _Cr = "Created";
+var _D = "Deployed";
+var _DAO = "DescribeAvailabilityOptions";
+var _DAOa = "DateArrayOptions";
+var _DAOo = "DoubleArrayOptions";
+var _DAS = "DefineAnalysisScheme";
+var _DASe = "DeleteAnalysisScheme";
+var _DASes = "DescribeAnalysisSchemes";
+var _DD = "DeleteDomain";
+var _DDEO = "DescribeDomainEndpointOptions";
+var _DDe = "DescribeDomains";
+var _DE = "DefineExpression";
+var _DEO = "DomainEndpointOptions";
+var _DEe = "DeleteExpression";
+var _DEes = "DescribeExpressions";
+var _DI = "DomainId";
+var _DIF = "DefineIndexField";
+var _DIFe = "DeleteIndexField";
+var _DIFes = "DescribeIndexFields";
+var _DIT = "DesiredInstanceType";
+var _DN = "DomainName";
+var _DNo = "DomainNames";
+var _DO = "DoubleOptions";
+var _DOa = "DateOptions";
+var _DPC = "DesiredPartitionCount";
+var _DRC = "DesiredReplicationCount";
+var _DS = "DefineSuggester";
+var _DSAP = "DescribeServiceAccessPolicies";
+var _DSL = "DomainStatusList";
+var _DSO = "DocumentSuggesterOptions";
+var _DSP = "DescribeScalingParameters";
+var _DSe = "DeleteSuggester";
+var _DSes = "DescribeSuggesters";
+var _DSo = "DomainStatus";
+var _DSoc = "DocService";
+var _DV = "DefaultValue";
+var _De = "Deleted";
+var _E = "Expression";
+var _EHTTPS = "EnforceHTTPS";
+var _EN = "ExpressionName";
+var _ENx = "ExpressionNames";
+var _EV = "ExpressionValue";
+var _En = "Endpoint";
+var _Ex = "Expressions";
+var _FE = "FacetEnabled";
+var _FM = "FuzzyMatching";
+var _FN = "FieldNames";
+var _HE = "HighlightEnabled";
+var _IAO = "IntArrayOptions";
+var _ID = "IndexDocuments";
+var _IF = "IndexField";
+var _IFN = "IndexFieldName";
+var _IFT = "IndexFieldType";
+var _IFn = "IndexFields";
+var _IO = "IntOptions";
+var _JTD = "JapaneseTokenizationDictionary";
+var _L = "Limits";
+var _LAO = "LiteralArrayOptions";
+var _LDN = "ListDomainNames";
+var _LLO = "LatLonOptions";
+var _LO = "LiteralOptions";
+var _M = "Message";
+var _MAZ = "MultiAZ";
+var _MPC = "MaximumPartitionCount";
+var _MRC = "MaximumReplicationCount";
+var _O = "Options";
+var _P = "Processing";
+var _PD = "PendingDeletion";
+var _RE = "ReturnEnabled";
+var _RID = "RequiresIndexDocuments";
+var _S = "Synonyms";
+var _SD = "StemmingDictionary";
+var _SE = "SearchEnabled";
+var _SEo = "SortEnabled";
+var _SEor = "SortExpression";
+var _SF = "SourceFields";
+var _SFo = "SourceField";
+var _SIC = "SearchInstanceCount";
+var _SIT = "SearchInstanceType";
+var _SN = "SuggesterName";
+var _SNu = "SuggesterNames";
+var _SP = "ScalingParameters";
+var _SPC = "SearchPartitionCount";
+var _SS = "SearchService";
+var _St = "Stopwords";
+var _Sta = "Status";
+var _Stat = "State";
+var _Su = "Suggester";
+var _Sug = "Suggesters";
+var _TAO = "TextArrayOptions";
+var _TLSSP = "TLSSecurityPolicy";
+var _TO = "TextOptions";
+var _UAO = "UpdateAvailabilityOptions";
+var _UD = "UpdateDate";
+var _UDEO = "UpdateDomainEndpointOptions";
+var _USAP = "UpdateServiceAccessPolicies";
+var _USP = "UpdateScalingParameters";
+var _UV = "UpdateVersion";
+var _V = "Version";
+var _e = "entry";
+var _m = "member";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    const parser = new import_fast_xml_parser.XMLParser({
+      attributeNamePrefix: "",
+      htmlEntities: true,
+      ignoreAttributes: false,
+      ignoreDeclaration: true,
+      parseTagValue: false,
+      trimValues: false,
+      tagValueProcessor: (_2, val) => val.trim() === "" && val.includes("\n") ? "" : void 0
+    });
+    parser.addEntity("#xD", "\r");
+    parser.addEntity("#10", "\n");
+    const parsedObj = parser.parse(encoded);
+    const textNodeName = "#text";
+    const key = Object.keys(parsedObj)[0];
+    const parsedObjToReturn = parsedObj[key];
+    if (parsedObjToReturn[textNodeName]) {
+      parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+      delete parsedObjToReturn[textNodeName];
+    }
+    return (0, import_smithy_client.getValueFromTextNode)(parsedObjToReturn);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  if (value.Error) {
+    value.Error.message = value.Error.message ?? value.Error.Message;
+  }
+  return value;
+}, "parseErrorBody");
+var buildFormUrlencodedString = /* @__PURE__ */ __name((formEntries) => Object.entries(formEntries).map(([key, value]) => (0, import_smithy_client.extendedEncodeURIComponent)(key) + "=" + (0, import_smithy_client.extendedEncodeURIComponent)(value)).join("&"), "buildFormUrlencodedString");
+var loadQueryErrorCode = /* @__PURE__ */ __name((output, data) => {
+  var _a;
+  if (((_a = data.Error) == null ? void 0 : _a.Code) !== void 0) {
+    return data.Error.Code;
+  }
+  if (output.statusCode == 404) {
+    return "NotFound";
+  }
+}, "loadQueryErrorCode");
+
+// src/commands/BuildSuggestersCommand.ts
+var _BuildSuggestersCommand = class _BuildSuggestersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "BuildSuggesters", {}).n("CloudSearchClient", "BuildSuggestersCommand").f(void 0, void 0).ser(se_BuildSuggestersCommand).de(de_BuildSuggestersCommand).build() {
+};
+__name(_BuildSuggestersCommand, "BuildSuggestersCommand");
+var BuildSuggestersCommand = _BuildSuggestersCommand;
+
+// src/commands/CreateDomainCommand.ts
+
+
+
+
+var _CreateDomainCommand = class _CreateDomainCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "CreateDomain", {}).n("CloudSearchClient", "CreateDomainCommand").f(void 0, void 0).ser(se_CreateDomainCommand).de(de_CreateDomainCommand).build() {
+};
+__name(_CreateDomainCommand, "CreateDomainCommand");
+var CreateDomainCommand = _CreateDomainCommand;
+
+// src/commands/DefineAnalysisSchemeCommand.ts
+
+
+
+
+var _DefineAnalysisSchemeCommand = class _DefineAnalysisSchemeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DefineAnalysisScheme", {}).n("CloudSearchClient", "DefineAnalysisSchemeCommand").f(void 0, void 0).ser(se_DefineAnalysisSchemeCommand).de(de_DefineAnalysisSchemeCommand).build() {
+};
+__name(_DefineAnalysisSchemeCommand, "DefineAnalysisSchemeCommand");
+var DefineAnalysisSchemeCommand = _DefineAnalysisSchemeCommand;
+
+// src/commands/DefineExpressionCommand.ts
+
+
+
+
+var _DefineExpressionCommand = class _DefineExpressionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DefineExpression", {}).n("CloudSearchClient", "DefineExpressionCommand").f(void 0, void 0).ser(se_DefineExpressionCommand).de(de_DefineExpressionCommand).build() {
+};
+__name(_DefineExpressionCommand, "DefineExpressionCommand");
+var DefineExpressionCommand = _DefineExpressionCommand;
+
+// src/commands/DefineIndexFieldCommand.ts
+
+
+
+
+var _DefineIndexFieldCommand = class _DefineIndexFieldCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DefineIndexField", {}).n("CloudSearchClient", "DefineIndexFieldCommand").f(void 0, void 0).ser(se_DefineIndexFieldCommand).de(de_DefineIndexFieldCommand).build() {
+};
+__name(_DefineIndexFieldCommand, "DefineIndexFieldCommand");
+var DefineIndexFieldCommand = _DefineIndexFieldCommand;
+
+// src/commands/DefineSuggesterCommand.ts
+
+
+
+
+var _DefineSuggesterCommand = class _DefineSuggesterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DefineSuggester", {}).n("CloudSearchClient", "DefineSuggesterCommand").f(void 0, void 0).ser(se_DefineSuggesterCommand).de(de_DefineSuggesterCommand).build() {
+};
+__name(_DefineSuggesterCommand, "DefineSuggesterCommand");
+var DefineSuggesterCommand = _DefineSuggesterCommand;
+
+// src/commands/DeleteAnalysisSchemeCommand.ts
+
+
+
+
+var _DeleteAnalysisSchemeCommand = class _DeleteAnalysisSchemeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DeleteAnalysisScheme", {}).n("CloudSearchClient", "DeleteAnalysisSchemeCommand").f(void 0, void 0).ser(se_DeleteAnalysisSchemeCommand).de(de_DeleteAnalysisSchemeCommand).build() {
+};
+__name(_DeleteAnalysisSchemeCommand, "DeleteAnalysisSchemeCommand");
+var DeleteAnalysisSchemeCommand = _DeleteAnalysisSchemeCommand;
+
+// src/commands/DeleteDomainCommand.ts
+
+
+
+
+var _DeleteDomainCommand = class _DeleteDomainCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DeleteDomain", {}).n("CloudSearchClient", "DeleteDomainCommand").f(void 0, void 0).ser(se_DeleteDomainCommand).de(de_DeleteDomainCommand).build() {
+};
+__name(_DeleteDomainCommand, "DeleteDomainCommand");
+var DeleteDomainCommand = _DeleteDomainCommand;
+
+// src/commands/DeleteExpressionCommand.ts
+
+
+
+
+var _DeleteExpressionCommand = class _DeleteExpressionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DeleteExpression", {}).n("CloudSearchClient", "DeleteExpressionCommand").f(void 0, void 0).ser(se_DeleteExpressionCommand).de(de_DeleteExpressionCommand).build() {
+};
+__name(_DeleteExpressionCommand, "DeleteExpressionCommand");
+var DeleteExpressionCommand = _DeleteExpressionCommand;
+
+// src/commands/DeleteIndexFieldCommand.ts
+
+
+
+
+var _DeleteIndexFieldCommand = class _DeleteIndexFieldCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DeleteIndexField", {}).n("CloudSearchClient", "DeleteIndexFieldCommand").f(void 0, void 0).ser(se_DeleteIndexFieldCommand).de(de_DeleteIndexFieldCommand).build() {
+};
+__name(_DeleteIndexFieldCommand, "DeleteIndexFieldCommand");
+var DeleteIndexFieldCommand = _DeleteIndexFieldCommand;
+
+// src/commands/DeleteSuggesterCommand.ts
+
+
+
+
+var _DeleteSuggesterCommand = class _DeleteSuggesterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DeleteSuggester", {}).n("CloudSearchClient", "DeleteSuggesterCommand").f(void 0, void 0).ser(se_DeleteSuggesterCommand).de(de_DeleteSuggesterCommand).build() {
+};
+__name(_DeleteSuggesterCommand, "DeleteSuggesterCommand");
+var DeleteSuggesterCommand = _DeleteSuggesterCommand;
+
+// src/commands/DescribeAnalysisSchemesCommand.ts
+
+
+
+
+var _DescribeAnalysisSchemesCommand = class _DescribeAnalysisSchemesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeAnalysisSchemes", {}).n("CloudSearchClient", "DescribeAnalysisSchemesCommand").f(void 0, void 0).ser(se_DescribeAnalysisSchemesCommand).de(de_DescribeAnalysisSchemesCommand).build() {
+};
+__name(_DescribeAnalysisSchemesCommand, "DescribeAnalysisSchemesCommand");
+var DescribeAnalysisSchemesCommand = _DescribeAnalysisSchemesCommand;
+
+// src/commands/DescribeAvailabilityOptionsCommand.ts
+
+
+
+
+var _DescribeAvailabilityOptionsCommand = class _DescribeAvailabilityOptionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeAvailabilityOptions", {}).n("CloudSearchClient", "DescribeAvailabilityOptionsCommand").f(void 0, void 0).ser(se_DescribeAvailabilityOptionsCommand).de(de_DescribeAvailabilityOptionsCommand).build() {
+};
+__name(_DescribeAvailabilityOptionsCommand, "DescribeAvailabilityOptionsCommand");
+var DescribeAvailabilityOptionsCommand = _DescribeAvailabilityOptionsCommand;
+
+// src/commands/DescribeDomainEndpointOptionsCommand.ts
+
+
+
+
+var _DescribeDomainEndpointOptionsCommand = class _DescribeDomainEndpointOptionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeDomainEndpointOptions", {}).n("CloudSearchClient", "DescribeDomainEndpointOptionsCommand").f(void 0, void 0).ser(se_DescribeDomainEndpointOptionsCommand).de(de_DescribeDomainEndpointOptionsCommand).build() {
+};
+__name(_DescribeDomainEndpointOptionsCommand, "DescribeDomainEndpointOptionsCommand");
+var DescribeDomainEndpointOptionsCommand = _DescribeDomainEndpointOptionsCommand;
+
+// src/commands/DescribeDomainsCommand.ts
+
+
+
+
+var _DescribeDomainsCommand = class _DescribeDomainsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeDomains", {}).n("CloudSearchClient", "DescribeDomainsCommand").f(void 0, void 0).ser(se_DescribeDomainsCommand).de(de_DescribeDomainsCommand).build() {
+};
+__name(_DescribeDomainsCommand, "DescribeDomainsCommand");
+var DescribeDomainsCommand = _DescribeDomainsCommand;
+
+// src/commands/DescribeExpressionsCommand.ts
+
+
+
+
+var _DescribeExpressionsCommand = class _DescribeExpressionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeExpressions", {}).n("CloudSearchClient", "DescribeExpressionsCommand").f(void 0, void 0).ser(se_DescribeExpressionsCommand).de(de_DescribeExpressionsCommand).build() {
+};
+__name(_DescribeExpressionsCommand, "DescribeExpressionsCommand");
+var DescribeExpressionsCommand = _DescribeExpressionsCommand;
+
+// src/commands/DescribeIndexFieldsCommand.ts
+
+
+
+
+var _DescribeIndexFieldsCommand = class _DescribeIndexFieldsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeIndexFields", {}).n("CloudSearchClient", "DescribeIndexFieldsCommand").f(void 0, void 0).ser(se_DescribeIndexFieldsCommand).de(de_DescribeIndexFieldsCommand).build() {
+};
+__name(_DescribeIndexFieldsCommand, "DescribeIndexFieldsCommand");
+var DescribeIndexFieldsCommand = _DescribeIndexFieldsCommand;
+
+// src/commands/DescribeScalingParametersCommand.ts
+
+
+
+
+var _DescribeScalingParametersCommand = class _DescribeScalingParametersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeScalingParameters", {}).n("CloudSearchClient", "DescribeScalingParametersCommand").f(void 0, void 0).ser(se_DescribeScalingParametersCommand).de(de_DescribeScalingParametersCommand).build() {
+};
+__name(_DescribeScalingParametersCommand, "DescribeScalingParametersCommand");
+var DescribeScalingParametersCommand = _DescribeScalingParametersCommand;
+
+// src/commands/DescribeServiceAccessPoliciesCommand.ts
+
+
+
+
+var _DescribeServiceAccessPoliciesCommand = class _DescribeServiceAccessPoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeServiceAccessPolicies", {}).n("CloudSearchClient", "DescribeServiceAccessPoliciesCommand").f(void 0, void 0).ser(se_DescribeServiceAccessPoliciesCommand).de(de_DescribeServiceAccessPoliciesCommand).build() {
+};
+__name(_DescribeServiceAccessPoliciesCommand, "DescribeServiceAccessPoliciesCommand");
+var DescribeServiceAccessPoliciesCommand = _DescribeServiceAccessPoliciesCommand;
+
+// src/commands/DescribeSuggestersCommand.ts
+
+
+
+
+var _DescribeSuggestersCommand = class _DescribeSuggestersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "DescribeSuggesters", {}).n("CloudSearchClient", "DescribeSuggestersCommand").f(void 0, void 0).ser(se_DescribeSuggestersCommand).de(de_DescribeSuggestersCommand).build() {
+};
+__name(_DescribeSuggestersCommand, "DescribeSuggestersCommand");
+var DescribeSuggestersCommand = _DescribeSuggestersCommand;
+
+// src/commands/IndexDocumentsCommand.ts
+
+
+
+
+var _IndexDocumentsCommand = class _IndexDocumentsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "IndexDocuments", {}).n("CloudSearchClient", "IndexDocumentsCommand").f(void 0, void 0).ser(se_IndexDocumentsCommand).de(de_IndexDocumentsCommand).build() {
+};
+__name(_IndexDocumentsCommand, "IndexDocumentsCommand");
+var IndexDocumentsCommand = _IndexDocumentsCommand;
+
+// src/commands/ListDomainNamesCommand.ts
+
+
+
+
+var _ListDomainNamesCommand = class _ListDomainNamesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "ListDomainNames", {}).n("CloudSearchClient", "ListDomainNamesCommand").f(void 0, void 0).ser(se_ListDomainNamesCommand).de(de_ListDomainNamesCommand).build() {
+};
+__name(_ListDomainNamesCommand, "ListDomainNamesCommand");
+var ListDomainNamesCommand = _ListDomainNamesCommand;
+
+// src/commands/UpdateAvailabilityOptionsCommand.ts
+
+
+
+
+var _UpdateAvailabilityOptionsCommand = class _UpdateAvailabilityOptionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "UpdateAvailabilityOptions", {}).n("CloudSearchClient", "UpdateAvailabilityOptionsCommand").f(void 0, void 0).ser(se_UpdateAvailabilityOptionsCommand).de(de_UpdateAvailabilityOptionsCommand).build() {
+};
+__name(_UpdateAvailabilityOptionsCommand, "UpdateAvailabilityOptionsCommand");
+var UpdateAvailabilityOptionsCommand = _UpdateAvailabilityOptionsCommand;
+
+// src/commands/UpdateDomainEndpointOptionsCommand.ts
+
+
+
+
+var _UpdateDomainEndpointOptionsCommand = class _UpdateDomainEndpointOptionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "UpdateDomainEndpointOptions", {}).n("CloudSearchClient", "UpdateDomainEndpointOptionsCommand").f(void 0, void 0).ser(se_UpdateDomainEndpointOptionsCommand).de(de_UpdateDomainEndpointOptionsCommand).build() {
+};
+__name(_UpdateDomainEndpointOptionsCommand, "UpdateDomainEndpointOptionsCommand");
+var UpdateDomainEndpointOptionsCommand = _UpdateDomainEndpointOptionsCommand;
+
+// src/commands/UpdateScalingParametersCommand.ts
+
+
+
+
+var _UpdateScalingParametersCommand = class _UpdateScalingParametersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "UpdateScalingParameters", {}).n("CloudSearchClient", "UpdateScalingParametersCommand").f(void 0, void 0).ser(se_UpdateScalingParametersCommand).de(de_UpdateScalingParametersCommand).build() {
+};
+__name(_UpdateScalingParametersCommand, "UpdateScalingParametersCommand");
+var UpdateScalingParametersCommand = _UpdateScalingParametersCommand;
+
+// src/commands/UpdateServiceAccessPoliciesCommand.ts
+
+
+
+
+var _UpdateServiceAccessPoliciesCommand = class _UpdateServiceAccessPoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("A9SearchCloudConfigService2013", "UpdateServiceAccessPolicies", {}).n("CloudSearchClient", "UpdateServiceAccessPoliciesCommand").f(void 0, void 0).ser(se_UpdateServiceAccessPoliciesCommand).de(de_UpdateServiceAccessPoliciesCommand).build() {
+};
+__name(_UpdateServiceAccessPoliciesCommand, "UpdateServiceAccessPoliciesCommand");
+var UpdateServiceAccessPoliciesCommand = _UpdateServiceAccessPoliciesCommand;
+
+// src/CloudSearch.ts
+var commands = {
+  BuildSuggestersCommand,
+  CreateDomainCommand,
+  DefineAnalysisSchemeCommand,
+  DefineExpressionCommand,
+  DefineIndexFieldCommand,
+  DefineSuggesterCommand,
+  DeleteAnalysisSchemeCommand,
+  DeleteDomainCommand,
+  DeleteExpressionCommand,
+  DeleteIndexFieldCommand,
+  DeleteSuggesterCommand,
+  DescribeAnalysisSchemesCommand,
+  DescribeAvailabilityOptionsCommand,
+  DescribeDomainEndpointOptionsCommand,
+  DescribeDomainsCommand,
+  DescribeExpressionsCommand,
+  DescribeIndexFieldsCommand,
+  DescribeScalingParametersCommand,
+  DescribeServiceAccessPoliciesCommand,
+  DescribeSuggestersCommand,
+  IndexDocumentsCommand,
+  ListDomainNamesCommand,
+  UpdateAvailabilityOptionsCommand,
+  UpdateDomainEndpointOptionsCommand,
+  UpdateScalingParametersCommand,
+  UpdateServiceAccessPoliciesCommand
+};
+var _CloudSearch = class _CloudSearch extends CloudSearchClient {
+};
+__name(_CloudSearch, "CloudSearch");
+var CloudSearch = _CloudSearch;
+(0, import_smithy_client.createAggregatedClient)(commands, CloudSearch);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlgorithmicStemming,
+  AnalysisSchemeLanguage,
+  BaseException,
+  BuildSuggestersCommand,
+  CloudSearch,
+  CloudSearchClient,
+  CloudSearchServiceException,
+  CreateDomainCommand,
+  DefineAnalysisSchemeCommand,
+  DefineExpressionCommand,
+  DefineIndexFieldCommand,
+  DefineSuggesterCommand,
+  DeleteAnalysisSchemeCommand,
+  DeleteDomainCommand,
+  DeleteExpressionCommand,
+  DeleteIndexFieldCommand,
+  DeleteSuggesterCommand,
+  DescribeAnalysisSchemesCommand,
+  DescribeAvailabilityOptionsCommand,
+  DescribeDomainEndpointOptionsCommand,
+  DescribeDomainsCommand,
+  DescribeExpressionsCommand,
+  DescribeIndexFieldsCommand,
+  DescribeScalingParametersCommand,
+  DescribeServiceAccessPoliciesCommand,
+  DescribeSuggestersCommand,
+  DisabledOperationException,
+  IndexDocumentsCommand,
+  IndexFieldType,
+  InternalException,
+  InvalidTypeException,
+  LimitExceededException,
+  ListDomainNamesCommand,
+  OptionState,
+  PartitionInstanceType,
+  ResourceAlreadyExistsException,
+  ResourceNotFoundException,
+  SuggesterFuzzyMatching,
+  TLSSecurityPolicy,
+  UpdateAvailabilityOptionsCommand,
+  UpdateDomainEndpointOptionsCommand,
+  UpdateScalingParametersCommand,
+  UpdateServiceAccessPoliciesCommand,
+  ValidationException,
+  __Client
+});