@aws-sdk/client-connectcases 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3290 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectCasesServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ConnectCasesClient"), exports);
-tslib_1.__exportStar(require("./ConnectCases"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ConnectCasesServiceException_1 = require("./models/ConnectCasesServiceException");
-Object.defineProperty(exports, "ConnectCasesServiceException", { enumerable: true, get: function () { return ConnectCasesServiceException_1.ConnectCasesServiceException; } });
+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, {
+  AccessDeniedException: () => AccessDeniedException,
+  BatchGetFieldCommand: () => BatchGetFieldCommand,
+  BatchPutFieldOptionsCommand: () => BatchPutFieldOptionsCommand,
+  CaseFilter: () => CaseFilter,
+  CommentBodyTextType: () => CommentBodyTextType,
+  ConflictException: () => ConflictException,
+  ConnectCases: () => ConnectCases,
+  ConnectCasesClient: () => ConnectCasesClient,
+  ConnectCasesServiceException: () => ConnectCasesServiceException,
+  CreateCaseCommand: () => CreateCaseCommand,
+  CreateDomainCommand: () => CreateDomainCommand,
+  CreateFieldCommand: () => CreateFieldCommand,
+  CreateLayoutCommand: () => CreateLayoutCommand,
+  CreateRelatedItemCommand: () => CreateRelatedItemCommand,
+  CreateTemplateCommand: () => CreateTemplateCommand,
+  DeleteDomainCommand: () => DeleteDomainCommand,
+  DomainStatus: () => DomainStatus,
+  FieldFilter: () => FieldFilter,
+  FieldNamespace: () => FieldNamespace,
+  FieldType: () => FieldType,
+  FieldValueUnion: () => FieldValueUnion,
+  GetCaseCommand: () => GetCaseCommand,
+  GetCaseEventConfigurationCommand: () => GetCaseEventConfigurationCommand,
+  GetDomainCommand: () => GetDomainCommand,
+  GetLayoutCommand: () => GetLayoutCommand,
+  GetTemplateCommand: () => GetTemplateCommand,
+  InternalServerException: () => InternalServerException,
+  LayoutContent: () => LayoutContent,
+  ListCasesForContactCommand: () => ListCasesForContactCommand,
+  ListDomainsCommand: () => ListDomainsCommand,
+  ListFieldOptionsCommand: () => ListFieldOptionsCommand,
+  ListFieldsCommand: () => ListFieldsCommand,
+  ListLayoutsCommand: () => ListLayoutsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTemplatesCommand: () => ListTemplatesCommand,
+  Order: () => Order,
+  PutCaseEventConfigurationCommand: () => PutCaseEventConfigurationCommand,
+  RelatedItemContent: () => RelatedItemContent,
+  RelatedItemInputContent: () => RelatedItemInputContent,
+  RelatedItemType: () => RelatedItemType,
+  RelatedItemTypeFilter: () => RelatedItemTypeFilter,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SearchCasesCommand: () => SearchCasesCommand,
+  SearchRelatedItemsCommand: () => SearchRelatedItemsCommand,
+  Section: () => Section,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  TagResourceCommand: () => TagResourceCommand,
+  TemplateStatus: () => TemplateStatus,
+  ThrottlingException: () => ThrottlingException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateCaseCommand: () => UpdateCaseCommand,
+  UpdateFieldCommand: () => UpdateFieldCommand,
+  UpdateLayoutCommand: () => UpdateLayoutCommand,
+  UpdateTemplateCommand: () => UpdateTemplateCommand,
+  UserUnion: () => UserUnion,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateGetCase: () => paginateGetCase,
+  paginateListCasesForContact: () => paginateListCasesForContact,
+  paginateListDomains: () => paginateListDomains,
+  paginateListFieldOptions: () => paginateListFieldOptions,
+  paginateListFields: () => paginateListFields,
+  paginateListLayouts: () => paginateListLayouts,
+  paginateListTemplates: () => paginateListTemplates,
+  paginateSearchCases: () => paginateSearchCases,
+  paginateSearchRelatedItems: () => paginateSearchRelatedItems
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ConnectCasesClient.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: "cases"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ConnectCasesClient.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/ConnectCasesClient.ts
+var _ConnectCasesClient = class _ConnectCasesClient 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(_ConnectCasesClient, "ConnectCasesClient");
+var ConnectCasesClient = _ConnectCasesClient;
+
+// src/ConnectCases.ts
+
+
+// src/commands/BatchGetFieldCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/ConnectCasesServiceException.ts
+
+var _ConnectCasesServiceException = class _ConnectCasesServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ConnectCasesServiceException.prototype);
+  }
+};
+__name(_ConnectCasesServiceException, "ConnectCasesServiceException");
+var ConnectCasesServiceException = _ConnectCasesServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _ConflictException = class _ConflictException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var FieldValueUnion;
+((FieldValueUnion2) => {
+  FieldValueUnion2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.stringValue !== void 0)
+      return visitor.stringValue(value.stringValue);
+    if (value.doubleValue !== void 0)
+      return visitor.doubleValue(value.doubleValue);
+    if (value.booleanValue !== void 0)
+      return visitor.booleanValue(value.booleanValue);
+    if (value.emptyValue !== void 0)
+      return visitor.emptyValue(value.emptyValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FieldValueUnion || (FieldValueUnion = {}));
+var _InternalServerException = class _InternalServerException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var CommentBodyTextType = {
+  PLAINTEXT: "Text/Plain"
+};
+var RelatedItemInputContent;
+((RelatedItemInputContent3) => {
+  RelatedItemInputContent3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.contact !== void 0)
+      return visitor.contact(value.contact);
+    if (value.comment !== void 0)
+      return visitor.comment(value.comment);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RelatedItemInputContent || (RelatedItemInputContent = {}));
+var UserUnion;
+((UserUnion3) => {
+  UserUnion3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.userArn !== void 0)
+      return visitor.userArn(value.userArn);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(UserUnion || (UserUnion = {}));
+var RelatedItemType = {
+  COMMENT: "Comment",
+  CONTACT: "Contact"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends ConnectCasesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var RelatedItemTypeFilter;
+((RelatedItemTypeFilter3) => {
+  RelatedItemTypeFilter3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.contact !== void 0)
+      return visitor.contact(value.contact);
+    if (value.comment !== void 0)
+      return visitor.comment(value.comment);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RelatedItemTypeFilter || (RelatedItemTypeFilter = {}));
+var RelatedItemContent;
+((RelatedItemContent3) => {
+  RelatedItemContent3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.contact !== void 0)
+      return visitor.contact(value.contact);
+    if (value.comment !== void 0)
+      return visitor.comment(value.comment);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RelatedItemContent || (RelatedItemContent = {}));
+var FieldFilter;
+((FieldFilter2) => {
+  FieldFilter2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.equalTo !== void 0)
+      return visitor.equalTo(value.equalTo);
+    if (value.contains !== void 0)
+      return visitor.contains(value.contains);
+    if (value.greaterThan !== void 0)
+      return visitor.greaterThan(value.greaterThan);
+    if (value.greaterThanOrEqualTo !== void 0)
+      return visitor.greaterThanOrEqualTo(value.greaterThanOrEqualTo);
+    if (value.lessThan !== void 0)
+      return visitor.lessThan(value.lessThan);
+    if (value.lessThanOrEqualTo !== void 0)
+      return visitor.lessThanOrEqualTo(value.lessThanOrEqualTo);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FieldFilter || (FieldFilter = {}));
+var Order = {
+  ASCENDING: "Asc",
+  DESCENDING: "Desc"
+};
+var DomainStatus = {
+  ACTIVE: "Active",
+  CREATION_FAILED: "CreationFailed",
+  CREATION_IN_PROGRESS: "CreationInProgress"
+};
+var FieldNamespace = {
+  CUSTOM: "Custom",
+  SYSTEM: "System"
+};
+var FieldType = {
+  BOOLEAN: "Boolean",
+  DATE_TIME: "DateTime",
+  NUMBER: "Number",
+  SINGLE_SELECT: "SingleSelect",
+  TEXT: "Text",
+  URL: "Url"
+};
+var Section;
+((Section3) => {
+  Section3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.fieldGroup !== void 0)
+      return visitor.fieldGroup(value.fieldGroup);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Section || (Section = {}));
+var LayoutContent;
+((LayoutContent3) => {
+  LayoutContent3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.basic !== void 0)
+      return visitor.basic(value.basic);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(LayoutContent || (LayoutContent = {}));
+var TemplateStatus = {
+  ACTIVE: "Active",
+  INACTIVE: "Inactive"
+};
+var CaseFilter;
+((CaseFilter2) => {
+  CaseFilter2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.field !== void 0)
+      return visitor.field(value.field);
+    if (value.not !== void 0)
+      return visitor.not(value.not);
+    if (value.andAll !== void 0)
+      return visitor.andAll(value.andAll);
+    if (value.orAll !== void 0)
+      return visitor.orAll(value.orAll);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CaseFilter || (CaseFilter = {}));
+
+// src/protocols/Aws_restJson1.ts
+var se_BatchGetFieldCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/fields-batch");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      fields: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchGetFieldCommand");
+var se_BatchPutFieldOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/fields/{fieldId}/options");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("fieldId", () => input.fieldId, "{fieldId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      options: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_BatchPutFieldOptionsCommand");
+var se_CreateCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      fields: (_) => se_FieldValueList(_, context),
+      templateId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCaseCommand");
+var se_CreateDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      name: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateDomainCommand");
+var se_CreateFieldCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/fields");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      name: [],
+      type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateFieldCommand");
+var se_CreateLayoutCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/layouts");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      content: (_) => (0, import_smithy_client._json)(_),
+      name: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateLayoutCommand");
+var se_CreateRelatedItemCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases/{caseId}/related-items");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("caseId", () => input.caseId, "{caseId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      content: (_) => (0, import_smithy_client._json)(_),
+      performedBy: (_) => (0, import_smithy_client._json)(_),
+      type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateRelatedItemCommand");
+var se_CreateTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/templates");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      layoutConfiguration: (_) => (0, import_smithy_client._json)(_),
+      name: [],
+      requiredFields: (_) => (0, import_smithy_client._json)(_),
+      status: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateTemplateCommand");
+var se_DeleteDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteDomainCommand");
+var se_GetCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases/{caseId}");
+  b.p("caseId", () => input.caseId, "{caseId}", false);
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      fields: (_) => (0, import_smithy_client._json)(_),
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetCaseCommand");
+var se_GetCaseEventConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/case-event-configuration");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetCaseEventConfigurationCommand");
+var se_GetDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetDomainCommand");
+var se_GetLayoutCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/layouts/{layoutId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("layoutId", () => input.layoutId, "{layoutId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetLayoutCommand");
+var se_GetTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/templates/{templateId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("templateId", () => input.templateId, "{templateId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetTemplateCommand");
+var se_ListCasesForContactCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/list-cases-for-contact");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      contactArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListCasesForContactCommand");
+var se_ListDomainsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains-list");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListDomainsCommand");
+var se_ListFieldOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/fields/{fieldId}/options-list");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("fieldId", () => input.fieldId, "{fieldId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]],
+    [_v]: [() => input.values !== void 0, () => (input[_v] || []).map((_entry) => _entry)]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListFieldOptionsCommand");
+var se_ListFieldsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/fields-list");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListFieldsCommand");
+var se_ListLayoutsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/layouts-list");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListLayoutsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{arn}");
+  b.p("arn", () => input.arn, "{arn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ListTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/domains/{domainId}/templates-list");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]],
+    [_s]: [() => input.status !== void 0, () => (input[_s] || []).map((_entry) => _entry)]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTemplatesCommand");
+var se_PutCaseEventConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/case-event-configuration");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      eventBridge: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutCaseEventConfigurationCommand");
+var se_SearchCasesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases-search");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      fields: (_) => (0, import_smithy_client._json)(_),
+      filter: (_) => se_CaseFilter(_, context),
+      maxResults: [],
+      nextToken: [],
+      searchTerm: [],
+      sorts: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SearchCasesCommand");
+var se_SearchRelatedItemsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases/{caseId}/related-items-search");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("caseId", () => input.caseId, "{caseId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filters: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SearchRelatedItemsCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{arn}");
+  b.p("arn", () => input.arn, "{arn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => se_Tags(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{arn}");
+  b.p("arn", () => input.arn, "{arn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/cases/{caseId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("caseId", () => input.caseId, "{caseId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      fields: (_) => se_FieldValueList(_, context)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateCaseCommand");
+var se_UpdateFieldCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/fields/{fieldId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("fieldId", () => input.fieldId, "{fieldId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      name: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFieldCommand");
+var se_UpdateLayoutCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/layouts/{layoutId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("layoutId", () => input.layoutId, "{layoutId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      content: (_) => (0, import_smithy_client._json)(_),
+      name: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateLayoutCommand");
+var se_UpdateTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/domains/{domainId}/templates/{templateId}");
+  b.p("domainId", () => input.domainId, "{domainId}", false);
+  b.p("templateId", () => input.templateId, "{templateId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      layoutConfiguration: (_) => (0, import_smithy_client._json)(_),
+      name: [],
+      requiredFields: (_) => (0, import_smithy_client._json)(_),
+      status: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateTemplateCommand");
+var de_BatchGetFieldCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchGetFieldCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    errors: import_smithy_client._json,
+    fields: (_) => de_BatchGetFieldList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchGetFieldCommand");
+var de_BatchGetFieldCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchGetFieldCommandError");
+var de_BatchPutFieldOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchPutFieldOptionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    errors: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchPutFieldOptionsCommand");
+var de_BatchPutFieldOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchPutFieldOptionsCommandError");
+var de_CreateCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateCaseCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    caseArn: import_smithy_client.expectString,
+    caseId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCaseCommand");
+var de_CreateCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCaseCommandError");
+var de_CreateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateDomainCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    domainArn: import_smithy_client.expectString,
+    domainId: import_smithy_client.expectString,
+    domainStatus: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateDomainCommand");
+var de_CreateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDomainCommandError");
+var de_CreateFieldCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateFieldCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    fieldArn: import_smithy_client.expectString,
+    fieldId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateFieldCommand");
+var de_CreateFieldCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateFieldCommandError");
+var de_CreateLayoutCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateLayoutCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    layoutArn: import_smithy_client.expectString,
+    layoutId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateLayoutCommand");
+var de_CreateLayoutCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLayoutCommandError");
+var de_CreateRelatedItemCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateRelatedItemCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    relatedItemArn: import_smithy_client.expectString,
+    relatedItemId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateRelatedItemCommand");
+var de_CreateRelatedItemCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRelatedItemCommandError");
+var de_CreateTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateTemplateCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    templateArn: import_smithy_client.expectString,
+    templateId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTemplateCommand");
+var de_CreateTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTemplateCommandError");
+var de_DeleteDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteDomainCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteDomainCommand");
+var de_DeleteDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDomainCommandError");
+var de_GetCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCaseCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    fields: (_) => de_FieldValueList(_, context),
+    nextToken: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context),
+    templateId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCaseCommand");
+var de_GetCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCaseCommandError");
+var de_GetCaseEventConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCaseEventConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    eventBridge: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCaseEventConfigurationCommand");
+var de_GetCaseEventConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCaseEventConfigurationCommandError");
+var de_GetDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDomainCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    createdTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    domainArn: import_smithy_client.expectString,
+    domainId: import_smithy_client.expectString,
+    domainStatus: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDomainCommand");
+var de_GetDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDomainCommandError");
+var de_GetLayoutCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetLayoutCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    content: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    layoutArn: import_smithy_client.expectString,
+    layoutId: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetLayoutCommand");
+var de_GetLayoutCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLayoutCommandError");
+var de_GetTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTemplateCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    description: import_smithy_client.expectString,
+    layoutConfiguration: import_smithy_client._json,
+    name: import_smithy_client.expectString,
+    requiredFields: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context),
+    templateArn: import_smithy_client.expectString,
+    templateId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTemplateCommand");
+var de_GetTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTemplateCommandError");
+var de_ListCasesForContactCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListCasesForContactCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    cases: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListCasesForContactCommand");
+var de_ListCasesForContactCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCasesForContactCommandError");
+var de_ListDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListDomainsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    domains: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListDomainsCommand");
+var de_ListDomainsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDomainsCommandError");
+var de_ListFieldOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListFieldOptionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    options: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFieldOptionsCommand");
+var de_ListFieldOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFieldOptionsCommandError");
+var de_ListFieldsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListFieldsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    fields: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFieldsCommand");
+var de_ListFieldsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFieldsCommandError");
+var de_ListLayoutsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListLayoutsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    layouts: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListLayoutsCommand");
+var de_ListLayoutsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLayoutsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: (_) => de_Tags(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTemplatesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    templates: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTemplatesCommand");
+var de_ListTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTemplatesCommandError");
+var de_PutCaseEventConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutCaseEventConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutCaseEventConfigurationCommand");
+var de_PutCaseEventConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutCaseEventConfigurationCommandError");
+var de_SearchCasesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SearchCasesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    cases: (_) => de_SearchCasesResponseItemList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SearchCasesCommand");
+var de_SearchCasesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchCasesCommandError");
+var de_SearchRelatedItemsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SearchRelatedItemsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    relatedItems: (_) => de_SearchRelatedItemsResponseItemList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SearchRelatedItemsCommand");
+var de_SearchRelatedItemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchRelatedItemsCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateCaseCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateCaseCommand");
+var de_UpdateCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCaseCommandError");
+var de_UpdateFieldCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateFieldCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateFieldCommand");
+var de_UpdateFieldCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFieldCommandError");
+var de_UpdateLayoutCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateLayoutCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateLayoutCommand");
+var de_UpdateLayoutCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.connectcases#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLayoutCommandError");
+var de_UpdateTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateTemplateCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateTemplateCommand");
+var de_UpdateTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.connectcases#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.connectcases#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.connectcases#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.connectcases#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.connectcases#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.connectcases#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateTemplateCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ConnectCasesServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_CaseFilter = /* @__PURE__ */ __name((input, context) => {
+  return CaseFilter.visit(input, {
+    andAll: (value) => ({ andAll: se_CaseFilterList(value, context) }),
+    field: (value) => ({ field: se_FieldFilter(value, context) }),
+    not: (value) => ({ not: se_CaseFilter(value, context) }),
+    orAll: (value) => ({ orAll: se_CaseFilterList(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_CaseFilter");
+var se_CaseFilterList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_CaseFilter(entry, context);
+  });
+}, "se_CaseFilterList");
+var se_FieldFilter = /* @__PURE__ */ __name((input, context) => {
+  return FieldFilter.visit(input, {
+    contains: (value) => ({ contains: se_FieldValue(value, context) }),
+    equalTo: (value) => ({ equalTo: se_FieldValue(value, context) }),
+    greaterThan: (value) => ({ greaterThan: se_FieldValue(value, context) }),
+    greaterThanOrEqualTo: (value) => ({ greaterThanOrEqualTo: se_FieldValue(value, context) }),
+    lessThan: (value) => ({ lessThan: se_FieldValue(value, context) }),
+    lessThanOrEqualTo: (value) => ({ lessThanOrEqualTo: se_FieldValue(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_FieldFilter");
+var se_FieldValue = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    id: [],
+    value: (_) => se_FieldValueUnion(_, context)
+  });
+}, "se_FieldValue");
+var se_FieldValueList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_FieldValue(entry, context);
+  });
+}, "se_FieldValueList");
+var se_FieldValueUnion = /* @__PURE__ */ __name((input, context) => {
+  return FieldValueUnion.visit(input, {
+    booleanValue: (value) => ({ booleanValue: value }),
+    doubleValue: (value) => ({ doubleValue: (0, import_smithy_client.serializeFloat)(value) }),
+    emptyValue: (value) => ({ emptyValue: (0, import_smithy_client._json)(value) }),
+    stringValue: (value) => ({ stringValue: value }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_FieldValueUnion");
+var se_Tags = /* @__PURE__ */ __name((input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      acc[key] = null;
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  }, {});
+}, "se_Tags");
+var de_BatchGetFieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GetFieldResponse(entry, context);
+  });
+  return retVal;
+}, "de_BatchGetFieldList");
+var de_ContactContent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    channel: import_smithy_client.expectString,
+    connectedToSystemTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    contactArn: import_smithy_client.expectString
+  });
+}, "de_ContactContent");
+var de_FieldValue = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    id: import_smithy_client.expectString,
+    value: (_) => de_FieldValueUnion((0, import_core.awsExpectUnion)(_), context)
+  });
+}, "de_FieldValue");
+var de_FieldValueList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FieldValue(entry, context);
+  });
+  return retVal;
+}, "de_FieldValueList");
+var de_FieldValueUnion = /* @__PURE__ */ __name((output, context) => {
+  if ((0, import_smithy_client.expectBoolean)(output.booleanValue) !== void 0) {
+    return { booleanValue: (0, import_smithy_client.expectBoolean)(output.booleanValue) };
+  }
+  if ((0, import_smithy_client.limitedParseDouble)(output.doubleValue) !== void 0) {
+    return { doubleValue: (0, import_smithy_client.limitedParseDouble)(output.doubleValue) };
+  }
+  if (output.emptyValue != null) {
+    return {
+      emptyValue: (0, import_smithy_client._json)(output.emptyValue)
+    };
+  }
+  if ((0, import_smithy_client.expectString)(output.stringValue) !== void 0) {
+    return { stringValue: (0, import_smithy_client.expectString)(output.stringValue) };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FieldValueUnion");
+var de_GetFieldResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: import_smithy_client.expectString,
+    fieldArn: import_smithy_client.expectString,
+    fieldId: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    namespace: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context),
+    type: import_smithy_client.expectString
+  });
+}, "de_GetFieldResponse");
+var de_RelatedItemContent = /* @__PURE__ */ __name((output, context) => {
+  if (output.comment != null) {
+    return {
+      comment: (0, import_smithy_client._json)(output.comment)
+    };
+  }
+  if (output.contact != null) {
+    return {
+      contact: de_ContactContent(output.contact, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_RelatedItemContent");
+var de_SearchCasesResponseItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    caseId: import_smithy_client.expectString,
+    fields: (_) => de_FieldValueList(_, context),
+    tags: (_) => de_Tags(_, context),
+    templateId: import_smithy_client.expectString
+  });
+}, "de_SearchCasesResponseItem");
+var de_SearchCasesResponseItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).map((entry) => {
+    if (entry === null) {
+      return null;
+    }
+    return de_SearchCasesResponseItem(entry, context);
+  });
+  return retVal;
+}, "de_SearchCasesResponseItemList");
+var de_SearchRelatedItemsResponseItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    associationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    content: (_) => de_RelatedItemContent((0, import_core.awsExpectUnion)(_), context),
+    performedBy: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    relatedItemId: import_smithy_client.expectString,
+    tags: (_) => de_Tags(_, context),
+    type: import_smithy_client.expectString
+  });
+}, "de_SearchRelatedItemsResponseItem");
+var de_SearchRelatedItemsResponseItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).map((entry) => {
+    if (entry === null) {
+      return null;
+    }
+    return de_SearchRelatedItemsResponseItem(entry, context);
+  });
+  return retVal;
+}, "de_SearchRelatedItemsResponseItemList");
+var de_Tags = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      acc[key] = null;
+      return acc;
+    }
+    acc[key] = (0, import_smithy_client.expectString)(value);
+    return acc;
+  }, {});
+}, "de_Tags");
+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 _mR = "maxResults";
+var _nT = "nextToken";
+var _rAS = "retryAfterSeconds";
+var _ra = "retry-after";
+var _s = "status";
+var _tK = "tagKeys";
+var _v = "values";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/BatchGetFieldCommand.ts
+var _BatchGetFieldCommand = class _BatchGetFieldCommand 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("AmazonConnectCases", "BatchGetField", {}).n("ConnectCasesClient", "BatchGetFieldCommand").f(void 0, void 0).ser(se_BatchGetFieldCommand).de(de_BatchGetFieldCommand).build() {
+};
+__name(_BatchGetFieldCommand, "BatchGetFieldCommand");
+var BatchGetFieldCommand = _BatchGetFieldCommand;
+
+// src/commands/BatchPutFieldOptionsCommand.ts
+
+
+
+
+var _BatchPutFieldOptionsCommand = class _BatchPutFieldOptionsCommand 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("AmazonConnectCases", "BatchPutFieldOptions", {}).n("ConnectCasesClient", "BatchPutFieldOptionsCommand").f(void 0, void 0).ser(se_BatchPutFieldOptionsCommand).de(de_BatchPutFieldOptionsCommand).build() {
+};
+__name(_BatchPutFieldOptionsCommand, "BatchPutFieldOptionsCommand");
+var BatchPutFieldOptionsCommand = _BatchPutFieldOptionsCommand;
+
+// src/commands/CreateCaseCommand.ts
+
+
+
+
+var _CreateCaseCommand = class _CreateCaseCommand 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("AmazonConnectCases", "CreateCase", {}).n("ConnectCasesClient", "CreateCaseCommand").f(void 0, void 0).ser(se_CreateCaseCommand).de(de_CreateCaseCommand).build() {
+};
+__name(_CreateCaseCommand, "CreateCaseCommand");
+var CreateCaseCommand = _CreateCaseCommand;
+
+// 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("AmazonConnectCases", "CreateDomain", {}).n("ConnectCasesClient", "CreateDomainCommand").f(void 0, void 0).ser(se_CreateDomainCommand).de(de_CreateDomainCommand).build() {
+};
+__name(_CreateDomainCommand, "CreateDomainCommand");
+var CreateDomainCommand = _CreateDomainCommand;
+
+// src/commands/CreateFieldCommand.ts
+
+
+
+
+var _CreateFieldCommand = class _CreateFieldCommand 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("AmazonConnectCases", "CreateField", {}).n("ConnectCasesClient", "CreateFieldCommand").f(void 0, void 0).ser(se_CreateFieldCommand).de(de_CreateFieldCommand).build() {
+};
+__name(_CreateFieldCommand, "CreateFieldCommand");
+var CreateFieldCommand = _CreateFieldCommand;
+
+// src/commands/CreateLayoutCommand.ts
+
+
+
+
+var _CreateLayoutCommand = class _CreateLayoutCommand 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("AmazonConnectCases", "CreateLayout", {}).n("ConnectCasesClient", "CreateLayoutCommand").f(void 0, void 0).ser(se_CreateLayoutCommand).de(de_CreateLayoutCommand).build() {
+};
+__name(_CreateLayoutCommand, "CreateLayoutCommand");
+var CreateLayoutCommand = _CreateLayoutCommand;
+
+// src/commands/CreateRelatedItemCommand.ts
+
+
+
+
+var _CreateRelatedItemCommand = class _CreateRelatedItemCommand 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("AmazonConnectCases", "CreateRelatedItem", {}).n("ConnectCasesClient", "CreateRelatedItemCommand").f(void 0, void 0).ser(se_CreateRelatedItemCommand).de(de_CreateRelatedItemCommand).build() {
+};
+__name(_CreateRelatedItemCommand, "CreateRelatedItemCommand");
+var CreateRelatedItemCommand = _CreateRelatedItemCommand;
+
+// src/commands/CreateTemplateCommand.ts
+
+
+
+
+var _CreateTemplateCommand = class _CreateTemplateCommand 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("AmazonConnectCases", "CreateTemplate", {}).n("ConnectCasesClient", "CreateTemplateCommand").f(void 0, void 0).ser(se_CreateTemplateCommand).de(de_CreateTemplateCommand).build() {
+};
+__name(_CreateTemplateCommand, "CreateTemplateCommand");
+var CreateTemplateCommand = _CreateTemplateCommand;
+
+// 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("AmazonConnectCases", "DeleteDomain", {}).n("ConnectCasesClient", "DeleteDomainCommand").f(void 0, void 0).ser(se_DeleteDomainCommand).de(de_DeleteDomainCommand).build() {
+};
+__name(_DeleteDomainCommand, "DeleteDomainCommand");
+var DeleteDomainCommand = _DeleteDomainCommand;
+
+// src/commands/GetCaseCommand.ts
+
+
+
+
+var _GetCaseCommand = class _GetCaseCommand 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("AmazonConnectCases", "GetCase", {}).n("ConnectCasesClient", "GetCaseCommand").f(void 0, void 0).ser(se_GetCaseCommand).de(de_GetCaseCommand).build() {
+};
+__name(_GetCaseCommand, "GetCaseCommand");
+var GetCaseCommand = _GetCaseCommand;
+
+// src/commands/GetCaseEventConfigurationCommand.ts
+
+
+
+
+var _GetCaseEventConfigurationCommand = class _GetCaseEventConfigurationCommand 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("AmazonConnectCases", "GetCaseEventConfiguration", {}).n("ConnectCasesClient", "GetCaseEventConfigurationCommand").f(void 0, void 0).ser(se_GetCaseEventConfigurationCommand).de(de_GetCaseEventConfigurationCommand).build() {
+};
+__name(_GetCaseEventConfigurationCommand, "GetCaseEventConfigurationCommand");
+var GetCaseEventConfigurationCommand = _GetCaseEventConfigurationCommand;
+
+// src/commands/GetDomainCommand.ts
+
+
+
+
+var _GetDomainCommand = class _GetDomainCommand 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("AmazonConnectCases", "GetDomain", {}).n("ConnectCasesClient", "GetDomainCommand").f(void 0, void 0).ser(se_GetDomainCommand).de(de_GetDomainCommand).build() {
+};
+__name(_GetDomainCommand, "GetDomainCommand");
+var GetDomainCommand = _GetDomainCommand;
+
+// src/commands/GetLayoutCommand.ts
+
+
+
+
+var _GetLayoutCommand = class _GetLayoutCommand 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("AmazonConnectCases", "GetLayout", {}).n("ConnectCasesClient", "GetLayoutCommand").f(void 0, void 0).ser(se_GetLayoutCommand).de(de_GetLayoutCommand).build() {
+};
+__name(_GetLayoutCommand, "GetLayoutCommand");
+var GetLayoutCommand = _GetLayoutCommand;
+
+// src/commands/GetTemplateCommand.ts
+
+
+
+
+var _GetTemplateCommand = class _GetTemplateCommand 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("AmazonConnectCases", "GetTemplate", {}).n("ConnectCasesClient", "GetTemplateCommand").f(void 0, void 0).ser(se_GetTemplateCommand).de(de_GetTemplateCommand).build() {
+};
+__name(_GetTemplateCommand, "GetTemplateCommand");
+var GetTemplateCommand = _GetTemplateCommand;
+
+// src/commands/ListCasesForContactCommand.ts
+
+
+
+
+var _ListCasesForContactCommand = class _ListCasesForContactCommand 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("AmazonConnectCases", "ListCasesForContact", {}).n("ConnectCasesClient", "ListCasesForContactCommand").f(void 0, void 0).ser(se_ListCasesForContactCommand).de(de_ListCasesForContactCommand).build() {
+};
+__name(_ListCasesForContactCommand, "ListCasesForContactCommand");
+var ListCasesForContactCommand = _ListCasesForContactCommand;
+
+// src/commands/ListDomainsCommand.ts
+
+
+
+
+var _ListDomainsCommand = class _ListDomainsCommand 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("AmazonConnectCases", "ListDomains", {}).n("ConnectCasesClient", "ListDomainsCommand").f(void 0, void 0).ser(se_ListDomainsCommand).de(de_ListDomainsCommand).build() {
+};
+__name(_ListDomainsCommand, "ListDomainsCommand");
+var ListDomainsCommand = _ListDomainsCommand;
+
+// src/commands/ListFieldOptionsCommand.ts
+
+
+
+
+var _ListFieldOptionsCommand = class _ListFieldOptionsCommand 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("AmazonConnectCases", "ListFieldOptions", {}).n("ConnectCasesClient", "ListFieldOptionsCommand").f(void 0, void 0).ser(se_ListFieldOptionsCommand).de(de_ListFieldOptionsCommand).build() {
+};
+__name(_ListFieldOptionsCommand, "ListFieldOptionsCommand");
+var ListFieldOptionsCommand = _ListFieldOptionsCommand;
+
+// src/commands/ListFieldsCommand.ts
+
+
+
+
+var _ListFieldsCommand = class _ListFieldsCommand 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("AmazonConnectCases", "ListFields", {}).n("ConnectCasesClient", "ListFieldsCommand").f(void 0, void 0).ser(se_ListFieldsCommand).de(de_ListFieldsCommand).build() {
+};
+__name(_ListFieldsCommand, "ListFieldsCommand");
+var ListFieldsCommand = _ListFieldsCommand;
+
+// src/commands/ListLayoutsCommand.ts
+
+
+
+
+var _ListLayoutsCommand = class _ListLayoutsCommand 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("AmazonConnectCases", "ListLayouts", {}).n("ConnectCasesClient", "ListLayoutsCommand").f(void 0, void 0).ser(se_ListLayoutsCommand).de(de_ListLayoutsCommand).build() {
+};
+__name(_ListLayoutsCommand, "ListLayoutsCommand");
+var ListLayoutsCommand = _ListLayoutsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("AmazonConnectCases", "ListTagsForResource", {}).n("ConnectCasesClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTemplatesCommand.ts
+
+
+
+
+var _ListTemplatesCommand = class _ListTemplatesCommand 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("AmazonConnectCases", "ListTemplates", {}).n("ConnectCasesClient", "ListTemplatesCommand").f(void 0, void 0).ser(se_ListTemplatesCommand).de(de_ListTemplatesCommand).build() {
+};
+__name(_ListTemplatesCommand, "ListTemplatesCommand");
+var ListTemplatesCommand = _ListTemplatesCommand;
+
+// src/commands/PutCaseEventConfigurationCommand.ts
+
+
+
+
+var _PutCaseEventConfigurationCommand = class _PutCaseEventConfigurationCommand 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("AmazonConnectCases", "PutCaseEventConfiguration", {}).n("ConnectCasesClient", "PutCaseEventConfigurationCommand").f(void 0, void 0).ser(se_PutCaseEventConfigurationCommand).de(de_PutCaseEventConfigurationCommand).build() {
+};
+__name(_PutCaseEventConfigurationCommand, "PutCaseEventConfigurationCommand");
+var PutCaseEventConfigurationCommand = _PutCaseEventConfigurationCommand;
+
+// src/commands/SearchCasesCommand.ts
+
+
+
+
+var _SearchCasesCommand = class _SearchCasesCommand 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("AmazonConnectCases", "SearchCases", {}).n("ConnectCasesClient", "SearchCasesCommand").f(void 0, void 0).ser(se_SearchCasesCommand).de(de_SearchCasesCommand).build() {
+};
+__name(_SearchCasesCommand, "SearchCasesCommand");
+var SearchCasesCommand = _SearchCasesCommand;
+
+// src/commands/SearchRelatedItemsCommand.ts
+
+
+
+
+var _SearchRelatedItemsCommand = class _SearchRelatedItemsCommand 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("AmazonConnectCases", "SearchRelatedItems", {}).n("ConnectCasesClient", "SearchRelatedItemsCommand").f(void 0, void 0).ser(se_SearchRelatedItemsCommand).de(de_SearchRelatedItemsCommand).build() {
+};
+__name(_SearchRelatedItemsCommand, "SearchRelatedItemsCommand");
+var SearchRelatedItemsCommand = _SearchRelatedItemsCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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("AmazonConnectCases", "TagResource", {}).n("ConnectCasesClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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("AmazonConnectCases", "UntagResource", {}).n("ConnectCasesClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateCaseCommand.ts
+
+
+
+
+var _UpdateCaseCommand = class _UpdateCaseCommand 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("AmazonConnectCases", "UpdateCase", {}).n("ConnectCasesClient", "UpdateCaseCommand").f(void 0, void 0).ser(se_UpdateCaseCommand).de(de_UpdateCaseCommand).build() {
+};
+__name(_UpdateCaseCommand, "UpdateCaseCommand");
+var UpdateCaseCommand = _UpdateCaseCommand;
+
+// src/commands/UpdateFieldCommand.ts
+
+
+
+
+var _UpdateFieldCommand = class _UpdateFieldCommand 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("AmazonConnectCases", "UpdateField", {}).n("ConnectCasesClient", "UpdateFieldCommand").f(void 0, void 0).ser(se_UpdateFieldCommand).de(de_UpdateFieldCommand).build() {
+};
+__name(_UpdateFieldCommand, "UpdateFieldCommand");
+var UpdateFieldCommand = _UpdateFieldCommand;
+
+// src/commands/UpdateLayoutCommand.ts
+
+
+
+
+var _UpdateLayoutCommand = class _UpdateLayoutCommand 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("AmazonConnectCases", "UpdateLayout", {}).n("ConnectCasesClient", "UpdateLayoutCommand").f(void 0, void 0).ser(se_UpdateLayoutCommand).de(de_UpdateLayoutCommand).build() {
+};
+__name(_UpdateLayoutCommand, "UpdateLayoutCommand");
+var UpdateLayoutCommand = _UpdateLayoutCommand;
+
+// src/commands/UpdateTemplateCommand.ts
+
+
+
+
+var _UpdateTemplateCommand = class _UpdateTemplateCommand 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("AmazonConnectCases", "UpdateTemplate", {}).n("ConnectCasesClient", "UpdateTemplateCommand").f(void 0, void 0).ser(se_UpdateTemplateCommand).de(de_UpdateTemplateCommand).build() {
+};
+__name(_UpdateTemplateCommand, "UpdateTemplateCommand");
+var UpdateTemplateCommand = _UpdateTemplateCommand;
+
+// src/ConnectCases.ts
+var commands = {
+  BatchGetFieldCommand,
+  BatchPutFieldOptionsCommand,
+  CreateCaseCommand,
+  CreateDomainCommand,
+  CreateFieldCommand,
+  CreateLayoutCommand,
+  CreateRelatedItemCommand,
+  CreateTemplateCommand,
+  DeleteDomainCommand,
+  GetCaseCommand,
+  GetCaseEventConfigurationCommand,
+  GetDomainCommand,
+  GetLayoutCommand,
+  GetTemplateCommand,
+  ListCasesForContactCommand,
+  ListDomainsCommand,
+  ListFieldOptionsCommand,
+  ListFieldsCommand,
+  ListLayoutsCommand,
+  ListTagsForResourceCommand,
+  ListTemplatesCommand,
+  PutCaseEventConfigurationCommand,
+  SearchCasesCommand,
+  SearchRelatedItemsCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCaseCommand,
+  UpdateFieldCommand,
+  UpdateLayoutCommand,
+  UpdateTemplateCommand
+};
+var _ConnectCases = class _ConnectCases extends ConnectCasesClient {
+};
+__name(_ConnectCases, "ConnectCases");
+var ConnectCases = _ConnectCases;
+(0, import_smithy_client.createAggregatedClient)(commands, ConnectCases);
+
+// src/pagination/GetCasePaginator.ts
+var import_core3 = require("@smithy/core");
+var paginateGetCase = (0, import_core3.createPaginator)(ConnectCasesClient, GetCaseCommand, "nextToken", "nextToken", "");
+
+// src/pagination/ListCasesForContactPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateListCasesForContact = (0, import_core4.createPaginator)(ConnectCasesClient, ListCasesForContactCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListDomainsPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateListDomains = (0, import_core5.createPaginator)(ConnectCasesClient, ListDomainsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFieldOptionsPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateListFieldOptions = (0, import_core6.createPaginator)(ConnectCasesClient, ListFieldOptionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFieldsPaginator.ts
+var import_core7 = require("@smithy/core");
+var paginateListFields = (0, import_core7.createPaginator)(ConnectCasesClient, ListFieldsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListLayoutsPaginator.ts
+var import_core8 = require("@smithy/core");
+var paginateListLayouts = (0, import_core8.createPaginator)(ConnectCasesClient, ListLayoutsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTemplatesPaginator.ts
+var import_core9 = require("@smithy/core");
+var paginateListTemplates = (0, import_core9.createPaginator)(ConnectCasesClient, ListTemplatesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchCasesPaginator.ts
+var import_core10 = require("@smithy/core");
+var paginateSearchCases = (0, import_core10.createPaginator)(ConnectCasesClient, SearchCasesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchRelatedItemsPaginator.ts
+var import_core11 = require("@smithy/core");
+var paginateSearchRelatedItems = (0, import_core11.createPaginator)(ConnectCasesClient, SearchRelatedItemsCommand, "nextToken", "nextToken", "maxResults");
+
+// 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 = {
+  AccessDeniedException,
+  BatchGetFieldCommand,
+  BatchPutFieldOptionsCommand,
+  CaseFilter,
+  CommentBodyTextType,
+  ConflictException,
+  ConnectCases,
+  ConnectCasesClient,
+  ConnectCasesServiceException,
+  CreateCaseCommand,
+  CreateDomainCommand,
+  CreateFieldCommand,
+  CreateLayoutCommand,
+  CreateRelatedItemCommand,
+  CreateTemplateCommand,
+  DeleteDomainCommand,
+  DomainStatus,
+  FieldFilter,
+  FieldNamespace,
+  FieldType,
+  FieldValueUnion,
+  GetCaseCommand,
+  GetCaseEventConfigurationCommand,
+  GetDomainCommand,
+  GetLayoutCommand,
+  GetTemplateCommand,
+  InternalServerException,
+  LayoutContent,
+  ListCasesForContactCommand,
+  ListDomainsCommand,
+  ListFieldOptionsCommand,
+  ListFieldsCommand,
+  ListLayoutsCommand,
+  ListTagsForResourceCommand,
+  ListTemplatesCommand,
+  Order,
+  PutCaseEventConfigurationCommand,
+  RelatedItemContent,
+  RelatedItemInputContent,
+  RelatedItemType,
+  RelatedItemTypeFilter,
+  ResourceNotFoundException,
+  SearchCasesCommand,
+  SearchRelatedItemsCommand,
+  Section,
+  ServiceQuotaExceededException,
+  TagResourceCommand,
+  TemplateStatus,
+  ThrottlingException,
+  UntagResourceCommand,
+  UpdateCaseCommand,
+  UpdateFieldCommand,
+  UpdateLayoutCommand,
+  UpdateTemplateCommand,
+  UserUnion,
+  ValidationException,
+  __Client,
+  paginateGetCase,
+  paginateListCasesForContact,
+  paginateListDomains,
+  paginateListFieldOptions,
+  paginateListFields,
+  paginateListLayouts,
+  paginateListTemplates,
+  paginateSearchCases,
+  paginateSearchRelatedItems
+});