@aws-sdk/client-textract 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,3431 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextractServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./TextractClient"), exports);
-tslib_1.__exportStar(require("./Textract"), 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 TextractServiceException_1 = require("./models/TextractServiceException");
-Object.defineProperty(exports, "TextractServiceException", { enumerable: true, get: function () { return TextractServiceException_1.TextractServiceException; } });
+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,
+  AdapterVersionStatus: () => AdapterVersionStatus,
+  AnalyzeDocumentCommand: () => AnalyzeDocumentCommand,
+  AnalyzeExpenseCommand: () => AnalyzeExpenseCommand,
+  AnalyzeIDCommand: () => AnalyzeIDCommand,
+  AutoUpdate: () => AutoUpdate,
+  BadDocumentException: () => BadDocumentException,
+  BlockType: () => BlockType,
+  ConflictException: () => ConflictException,
+  ContentClassifier: () => ContentClassifier,
+  CreateAdapterCommand: () => CreateAdapterCommand,
+  CreateAdapterVersionCommand: () => CreateAdapterVersionCommand,
+  DeleteAdapterCommand: () => DeleteAdapterCommand,
+  DeleteAdapterVersionCommand: () => DeleteAdapterVersionCommand,
+  DetectDocumentTextCommand: () => DetectDocumentTextCommand,
+  DocumentTooLargeException: () => DocumentTooLargeException,
+  EntityType: () => EntityType,
+  FeatureType: () => FeatureType,
+  GetAdapterCommand: () => GetAdapterCommand,
+  GetAdapterVersionCommand: () => GetAdapterVersionCommand,
+  GetDocumentAnalysisCommand: () => GetDocumentAnalysisCommand,
+  GetDocumentTextDetectionCommand: () => GetDocumentTextDetectionCommand,
+  GetExpenseAnalysisCommand: () => GetExpenseAnalysisCommand,
+  GetLendingAnalysisCommand: () => GetLendingAnalysisCommand,
+  GetLendingAnalysisSummaryCommand: () => GetLendingAnalysisSummaryCommand,
+  HumanLoopQuotaExceededException: () => HumanLoopQuotaExceededException,
+  IdempotentParameterMismatchException: () => IdempotentParameterMismatchException,
+  InternalServerError: () => InternalServerError,
+  InvalidJobIdException: () => InvalidJobIdException,
+  InvalidKMSKeyException: () => InvalidKMSKeyException,
+  InvalidParameterException: () => InvalidParameterException,
+  InvalidS3ObjectException: () => InvalidS3ObjectException,
+  JobStatus: () => JobStatus,
+  LimitExceededException: () => LimitExceededException,
+  ListAdapterVersionsCommand: () => ListAdapterVersionsCommand,
+  ListAdaptersCommand: () => ListAdaptersCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ProvisionedThroughputExceededException: () => ProvisionedThroughputExceededException,
+  RelationshipType: () => RelationshipType,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SelectionStatus: () => SelectionStatus,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartDocumentAnalysisCommand: () => StartDocumentAnalysisCommand,
+  StartDocumentTextDetectionCommand: () => StartDocumentTextDetectionCommand,
+  StartExpenseAnalysisCommand: () => StartExpenseAnalysisCommand,
+  StartLendingAnalysisCommand: () => StartLendingAnalysisCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TextType: () => TextType,
+  Textract: () => Textract,
+  TextractClient: () => TextractClient,
+  TextractServiceException: () => TextractServiceException,
+  ThrottlingException: () => ThrottlingException,
+  UnsupportedDocumentException: () => UnsupportedDocumentException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateAdapterCommand: () => UpdateAdapterCommand,
+  ValidationException: () => ValidationException,
+  ValueType: () => ValueType,
+  __Client: () => import_smithy_client.Client,
+  paginateListAdapterVersions: () => paginateListAdapterVersions,
+  paginateListAdapters: () => paginateListAdapters
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/TextractClient.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: "textract"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/TextractClient.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/TextractClient.ts
+var _TextractClient = class _TextractClient 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(_TextractClient, "TextractClient");
+var TextractClient = _TextractClient;
+
+// src/Textract.ts
+
+
+// src/commands/AnalyzeDocumentCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+var import_uuid = require("uuid");
+
+// src/models/TextractServiceException.ts
+
+var _TextractServiceException = class _TextractServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _TextractServiceException.prototype);
+  }
+};
+__name(_TextractServiceException, "TextractServiceException");
+var TextractServiceException = _TextractServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var FeatureType = {
+  FORMS: "FORMS",
+  LAYOUT: "LAYOUT",
+  QUERIES: "QUERIES",
+  SIGNATURES: "SIGNATURES",
+  TABLES: "TABLES"
+};
+var AdapterVersionStatus = {
+  ACTIVE: "ACTIVE",
+  AT_RISK: "AT_RISK",
+  CREATION_ERROR: "CREATION_ERROR",
+  CREATION_IN_PROGRESS: "CREATION_IN_PROGRESS",
+  DEPRECATED: "DEPRECATED"
+};
+var ContentClassifier = {
+  FREE_OF_ADULT_CONTENT: "FreeOfAdultContent",
+  FREE_OF_PERSONALLY_IDENTIFIABLE_INFORMATION: "FreeOfPersonallyIdentifiableInformation"
+};
+var BlockType = {
+  CELL: "CELL",
+  KEY_VALUE_SET: "KEY_VALUE_SET",
+  LAYOUT_FIGURE: "LAYOUT_FIGURE",
+  LAYOUT_FOOTER: "LAYOUT_FOOTER",
+  LAYOUT_HEADER: "LAYOUT_HEADER",
+  LAYOUT_KEY_VALUE: "LAYOUT_KEY_VALUE",
+  LAYOUT_LIST: "LAYOUT_LIST",
+  LAYOUT_PAGE_NUMBER: "LAYOUT_PAGE_NUMBER",
+  LAYOUT_SECTION_HEADER: "LAYOUT_SECTION_HEADER",
+  LAYOUT_TABLE: "LAYOUT_TABLE",
+  LAYOUT_TEXT: "LAYOUT_TEXT",
+  LAYOUT_TITLE: "LAYOUT_TITLE",
+  LINE: "LINE",
+  MERGED_CELL: "MERGED_CELL",
+  PAGE: "PAGE",
+  QUERY: "QUERY",
+  QUERY_RESULT: "QUERY_RESULT",
+  SELECTION_ELEMENT: "SELECTION_ELEMENT",
+  SIGNATURE: "SIGNATURE",
+  TABLE: "TABLE",
+  TABLE_FOOTER: "TABLE_FOOTER",
+  TABLE_TITLE: "TABLE_TITLE",
+  TITLE: "TITLE",
+  WORD: "WORD"
+};
+var EntityType = {
+  COLUMN_HEADER: "COLUMN_HEADER",
+  KEY: "KEY",
+  SEMI_STRUCTURED_TABLE: "SEMI_STRUCTURED_TABLE",
+  STRUCTURED_TABLE: "STRUCTURED_TABLE",
+  TABLE_FOOTER: "TABLE_FOOTER",
+  TABLE_SECTION_TITLE: "TABLE_SECTION_TITLE",
+  TABLE_SUMMARY: "TABLE_SUMMARY",
+  TABLE_TITLE: "TABLE_TITLE",
+  VALUE: "VALUE"
+};
+var RelationshipType = {
+  ANSWER: "ANSWER",
+  CHILD: "CHILD",
+  COMPLEX_FEATURES: "COMPLEX_FEATURES",
+  MERGED_CELL: "MERGED_CELL",
+  TABLE: "TABLE",
+  TABLE_FOOTER: "TABLE_FOOTER",
+  TABLE_TITLE: "TABLE_TITLE",
+  TITLE: "TITLE",
+  VALUE: "VALUE"
+};
+var SelectionStatus = {
+  NOT_SELECTED: "NOT_SELECTED",
+  SELECTED: "SELECTED"
+};
+var TextType = {
+  HANDWRITING: "HANDWRITING",
+  PRINTED: "PRINTED"
+};
+var _BadDocumentException = class _BadDocumentException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadDocumentException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadDocumentException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadDocumentException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_BadDocumentException, "BadDocumentException");
+var BadDocumentException = _BadDocumentException;
+var _DocumentTooLargeException = class _DocumentTooLargeException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DocumentTooLargeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DocumentTooLargeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DocumentTooLargeException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_DocumentTooLargeException, "DocumentTooLargeException");
+var DocumentTooLargeException = _DocumentTooLargeException;
+var _HumanLoopQuotaExceededException = class _HumanLoopQuotaExceededException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "HumanLoopQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "HumanLoopQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _HumanLoopQuotaExceededException.prototype);
+    this.ResourceType = opts.ResourceType;
+    this.QuotaCode = opts.QuotaCode;
+    this.ServiceCode = opts.ServiceCode;
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_HumanLoopQuotaExceededException, "HumanLoopQuotaExceededException");
+var HumanLoopQuotaExceededException = _HumanLoopQuotaExceededException;
+var _InternalServerError = class _InternalServerError extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerError.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+var _InvalidParameterException = class _InvalidParameterException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _InvalidS3ObjectException = class _InvalidS3ObjectException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidS3ObjectException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidS3ObjectException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidS3ObjectException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_InvalidS3ObjectException, "InvalidS3ObjectException");
+var InvalidS3ObjectException = _InvalidS3ObjectException;
+var _ProvisionedThroughputExceededException = class _ProvisionedThroughputExceededException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ProvisionedThroughputExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ProvisionedThroughputExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ProvisionedThroughputExceededException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ProvisionedThroughputExceededException, "ProvisionedThroughputExceededException");
+var ProvisionedThroughputExceededException = _ProvisionedThroughputExceededException;
+var _ThrottlingException = class _ThrottlingException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _UnsupportedDocumentException = class _UnsupportedDocumentException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedDocumentException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedDocumentException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedDocumentException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_UnsupportedDocumentException, "UnsupportedDocumentException");
+var UnsupportedDocumentException = _UnsupportedDocumentException;
+var ValueType = {
+  DATE: "DATE"
+};
+var AutoUpdate = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _ConflictException = class _ConflictException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _IdempotentParameterMismatchException = class _IdempotentParameterMismatchException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IdempotentParameterMismatchException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IdempotentParameterMismatchException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IdempotentParameterMismatchException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_IdempotentParameterMismatchException, "IdempotentParameterMismatchException");
+var IdempotentParameterMismatchException = _IdempotentParameterMismatchException;
+var _LimitExceededException = class _LimitExceededException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ValidationException = class _ValidationException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _InvalidKMSKeyException = class _InvalidKMSKeyException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidKMSKeyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidKMSKeyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidKMSKeyException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_InvalidKMSKeyException, "InvalidKMSKeyException");
+var InvalidKMSKeyException = _InvalidKMSKeyException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var JobStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var _InvalidJobIdException = class _InvalidJobIdException extends TextractServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidJobIdException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidJobIdException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidJobIdException.prototype);
+    this.Message = opts.Message;
+    this.Code = opts.Code;
+  }
+};
+__name(_InvalidJobIdException, "InvalidJobIdException");
+var InvalidJobIdException = _InvalidJobIdException;
+
+// src/protocols/Aws_json1_1.ts
+var se_AnalyzeDocumentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AnalyzeDocument");
+  let body;
+  body = JSON.stringify(se_AnalyzeDocumentRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AnalyzeDocumentCommand");
+var se_AnalyzeExpenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AnalyzeExpense");
+  let body;
+  body = JSON.stringify(se_AnalyzeExpenseRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AnalyzeExpenseCommand");
+var se_AnalyzeIDCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AnalyzeID");
+  let body;
+  body = JSON.stringify(se_AnalyzeIDRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AnalyzeIDCommand");
+var se_CreateAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAdapter");
+  let body;
+  body = JSON.stringify(se_CreateAdapterRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAdapterCommand");
+var se_CreateAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAdapterVersion");
+  let body;
+  body = JSON.stringify(se_CreateAdapterVersionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAdapterVersionCommand");
+var se_DeleteAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAdapter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAdapterCommand");
+var se_DeleteAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAdapterVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAdapterVersionCommand");
+var se_DetectDocumentTextCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DetectDocumentText");
+  let body;
+  body = JSON.stringify(se_DetectDocumentTextRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DetectDocumentTextCommand");
+var se_GetAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAdapter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAdapterCommand");
+var se_GetAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAdapterVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAdapterVersionCommand");
+var se_GetDocumentAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetDocumentAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetDocumentAnalysisCommand");
+var se_GetDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetDocumentTextDetection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetDocumentTextDetectionCommand");
+var se_GetExpenseAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetExpenseAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetExpenseAnalysisCommand");
+var se_GetLendingAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLendingAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLendingAnalysisCommand");
+var se_GetLendingAnalysisSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLendingAnalysisSummary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLendingAnalysisSummaryCommand");
+var se_ListAdaptersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAdapters");
+  let body;
+  body = JSON.stringify(se_ListAdaptersRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAdaptersCommand");
+var se_ListAdapterVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAdapterVersions");
+  let body;
+  body = JSON.stringify(se_ListAdapterVersionsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAdapterVersionsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_StartDocumentAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartDocumentAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartDocumentAnalysisCommand");
+var se_StartDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartDocumentTextDetection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartDocumentTextDetectionCommand");
+var se_StartExpenseAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartExpenseAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartExpenseAnalysisCommand");
+var se_StartLendingAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartLendingAnalysis");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartLendingAnalysisCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateAdapter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateAdapterCommand");
+var de_AnalyzeDocumentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AnalyzeDocumentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AnalyzeDocumentResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AnalyzeDocumentCommand");
+var de_AnalyzeDocumentCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "HumanLoopQuotaExceededException":
+    case "com.amazonaws.textract#HumanLoopQuotaExceededException":
+      throw await de_HumanLoopQuotaExceededExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AnalyzeDocumentCommandError");
+var de_AnalyzeExpenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AnalyzeExpenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AnalyzeExpenseResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AnalyzeExpenseCommand");
+var de_AnalyzeExpenseCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AnalyzeExpenseCommandError");
+var de_AnalyzeIDCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AnalyzeIDCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AnalyzeIDResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AnalyzeIDCommand");
+var de_AnalyzeIDCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AnalyzeIDCommandError");
+var de_CreateAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAdapterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateAdapterCommand");
+var de_CreateAdapterCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.textract#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.textract#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAdapterCommandError");
+var de_CreateAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAdapterVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateAdapterVersionCommand");
+var de_CreateAdapterVersionCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.textract#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.textract#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAdapterVersionCommandError");
+var de_DeleteAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAdapterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAdapterCommand");
+var de_DeleteAdapterCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.textract#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAdapterCommandError");
+var de_DeleteAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAdapterVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteAdapterVersionCommand");
+var de_DeleteAdapterVersionCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.textract#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAdapterVersionCommandError");
+var de_DetectDocumentTextCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DetectDocumentTextCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DetectDocumentTextResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DetectDocumentTextCommand");
+var de_DetectDocumentTextCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DetectDocumentTextCommandError");
+var de_GetAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAdapterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAdapterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAdapterCommand");
+var de_GetAdapterCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAdapterCommandError");
+var de_GetAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAdapterVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAdapterVersionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAdapterVersionCommand");
+var de_GetAdapterVersionCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAdapterVersionCommandError");
+var de_GetDocumentAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetDocumentAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetDocumentAnalysisResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetDocumentAnalysisCommand");
+var de_GetDocumentAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidJobIdException":
+    case "com.amazonaws.textract#InvalidJobIdException":
+      throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDocumentAnalysisCommandError");
+var de_GetDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetDocumentTextDetectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetDocumentTextDetectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetDocumentTextDetectionCommand");
+var de_GetDocumentTextDetectionCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidJobIdException":
+    case "com.amazonaws.textract#InvalidJobIdException":
+      throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDocumentTextDetectionCommandError");
+var de_GetExpenseAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetExpenseAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetExpenseAnalysisResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetExpenseAnalysisCommand");
+var de_GetExpenseAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidJobIdException":
+    case "com.amazonaws.textract#InvalidJobIdException":
+      throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetExpenseAnalysisCommandError");
+var de_GetLendingAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLendingAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetLendingAnalysisResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLendingAnalysisCommand");
+var de_GetLendingAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidJobIdException":
+    case "com.amazonaws.textract#InvalidJobIdException":
+      throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLendingAnalysisCommandError");
+var de_GetLendingAnalysisSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLendingAnalysisSummaryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLendingAnalysisSummaryCommand");
+var de_GetLendingAnalysisSummaryCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidJobIdException":
+    case "com.amazonaws.textract#InvalidJobIdException":
+      throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLendingAnalysisSummaryCommandError");
+var de_ListAdaptersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAdaptersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAdaptersResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAdaptersCommand");
+var de_ListAdaptersCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAdaptersCommandError");
+var de_ListAdapterVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAdapterVersionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAdapterVersionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAdapterVersionsCommand");
+var de_ListAdapterVersionsCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAdapterVersionsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartDocumentAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartDocumentAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartDocumentAnalysisCommand");
+var de_StartDocumentAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartDocumentAnalysisCommandError");
+var de_StartDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartDocumentTextDetectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartDocumentTextDetectionCommand");
+var de_StartDocumentTextDetectionCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartDocumentTextDetectionCommandError");
+var de_StartExpenseAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartExpenseAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartExpenseAnalysisCommand");
+var de_StartExpenseAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartExpenseAnalysisCommandError");
+var de_StartLendingAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartLendingAnalysisCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartLendingAnalysisCommand");
+var de_StartLendingAnalysisCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadDocumentException":
+    case "com.amazonaws.textract#BadDocumentException":
+      throw await de_BadDocumentExceptionRes(parsedOutput, context);
+    case "DocumentTooLargeException":
+    case "com.amazonaws.textract#DocumentTooLargeException":
+      throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.textract#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidKMSKeyException":
+    case "com.amazonaws.textract#InvalidKMSKeyException":
+      throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidS3ObjectException":
+    case "com.amazonaws.textract#InvalidS3ObjectException":
+      throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.textract#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedDocumentException":
+    case "com.amazonaws.textract#UnsupportedDocumentException":
+      throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartLendingAnalysisCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.textract#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#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 >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateAdapterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateAdapterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateAdapterCommand");
+var de_UpdateAdapterCommandError = /* @__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.textract#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.textract#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.textract#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.textract#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ProvisionedThroughputExceededException":
+    case "com.amazonaws.textract#ProvisionedThroughputExceededException":
+      throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.textract#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.textract#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.textract#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateAdapterCommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_BadDocumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new BadDocumentException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_BadDocumentExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+var de_DocumentTooLargeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DocumentTooLargeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DocumentTooLargeExceptionRes");
+var de_HumanLoopQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new HumanLoopQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_HumanLoopQuotaExceededExceptionRes");
+var de_IdempotentParameterMismatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new IdempotentParameterMismatchException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_IdempotentParameterMismatchExceptionRes");
+var de_InternalServerErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServerError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServerErrorRes");
+var de_InvalidJobIdExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidJobIdException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidJobIdExceptionRes");
+var de_InvalidKMSKeyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidKMSKeyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidKMSKeyExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterExceptionRes");
+var de_InvalidS3ObjectExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidS3ObjectException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidS3ObjectExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_ProvisionedThroughputExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ProvisionedThroughputExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ProvisionedThroughputExceededExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ThrottlingExceptionRes");
+var de_UnsupportedDocumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedDocumentException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedDocumentExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var se_AnalyzeDocumentRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AdaptersConfig: import_smithy_client._json,
+    Document: (_) => se_Document(_, context),
+    FeatureTypes: import_smithy_client._json,
+    HumanLoopConfig: import_smithy_client._json,
+    QueriesConfig: import_smithy_client._json
+  });
+}, "se_AnalyzeDocumentRequest");
+var se_AnalyzeExpenseRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Document: (_) => se_Document(_, context)
+  });
+}, "se_AnalyzeExpenseRequest");
+var se_AnalyzeIDRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    DocumentPages: (_) => se_DocumentPages(_, context)
+  });
+}, "se_AnalyzeIDRequest");
+var se_CreateAdapterRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AdapterName: [],
+    AutoUpdate: [],
+    ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    Description: [],
+    FeatureTypes: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+}, "se_CreateAdapterRequest");
+var se_CreateAdapterVersionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AdapterId: [],
+    ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    DatasetConfig: import_smithy_client._json,
+    KMSKeyId: [],
+    OutputConfig: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+}, "se_CreateAdapterVersionRequest");
+var se_DetectDocumentTextRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Document: (_) => se_Document(_, context)
+  });
+}, "se_DetectDocumentTextRequest");
+var se_Document = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Bytes: context.base64Encoder,
+    S3Object: import_smithy_client._json
+  });
+}, "se_Document");
+var se_DocumentPages = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Document(entry, context);
+  });
+}, "se_DocumentPages");
+var se_ListAdaptersRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AfterCreationTime: (_) => Math.round(_.getTime() / 1e3),
+    BeforeCreationTime: (_) => Math.round(_.getTime() / 1e3),
+    MaxResults: [],
+    NextToken: []
+  });
+}, "se_ListAdaptersRequest");
+var se_ListAdapterVersionsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AdapterId: [],
+    AfterCreationTime: (_) => Math.round(_.getTime() / 1e3),
+    BeforeCreationTime: (_) => Math.round(_.getTime() / 1e3),
+    MaxResults: [],
+    NextToken: []
+  });
+}, "se_ListAdapterVersionsRequest");
+var de_AdapterList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AdapterOverview(entry, context);
+  });
+  return retVal;
+}, "de_AdapterList");
+var de_AdapterOverview = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterId: import_smithy_client.expectString,
+    AdapterName: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FeatureTypes: import_smithy_client._json
+  });
+}, "de_AdapterOverview");
+var de_AdapterVersionEvaluationMetric = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterVersion: (_) => de_EvaluationMetric(_, context),
+    Baseline: (_) => de_EvaluationMetric(_, context),
+    FeatureType: import_smithy_client.expectString
+  });
+}, "de_AdapterVersionEvaluationMetric");
+var de_AdapterVersionEvaluationMetrics = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AdapterVersionEvaluationMetric(entry, context);
+  });
+  return retVal;
+}, "de_AdapterVersionEvaluationMetrics");
+var de_AdapterVersionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AdapterVersionOverview(entry, context);
+  });
+  return retVal;
+}, "de_AdapterVersionList");
+var de_AdapterVersionOverview = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterId: import_smithy_client.expectString,
+    AdapterVersion: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FeatureTypes: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString
+  });
+}, "de_AdapterVersionOverview");
+var de_AnalyzeDocumentResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalyzeDocumentModelVersion: import_smithy_client.expectString,
+    Blocks: (_) => de_BlockList(_, context),
+    DocumentMetadata: import_smithy_client._json,
+    HumanLoopActivationOutput: (_) => de_HumanLoopActivationOutput(_, context)
+  });
+}, "de_AnalyzeDocumentResponse");
+var de_AnalyzeExpenseResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DocumentMetadata: import_smithy_client._json,
+    ExpenseDocuments: (_) => de_ExpenseDocumentList(_, context)
+  });
+}, "de_AnalyzeExpenseResponse");
+var de_AnalyzeIDDetections = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    NormalizedValue: import_smithy_client._json,
+    Text: import_smithy_client.expectString
+  });
+}, "de_AnalyzeIDDetections");
+var de_AnalyzeIDResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalyzeIDModelVersion: import_smithy_client.expectString,
+    DocumentMetadata: import_smithy_client._json,
+    IdentityDocuments: (_) => de_IdentityDocumentList(_, context)
+  });
+}, "de_AnalyzeIDResponse");
+var de_Block = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BlockType: import_smithy_client.expectString,
+    ColumnIndex: import_smithy_client.expectInt32,
+    ColumnSpan: import_smithy_client.expectInt32,
+    Confidence: import_smithy_client.limitedParseFloat32,
+    EntityTypes: import_smithy_client._json,
+    Geometry: (_) => de_Geometry(_, context),
+    Id: import_smithy_client.expectString,
+    Page: import_smithy_client.expectInt32,
+    Query: import_smithy_client._json,
+    Relationships: import_smithy_client._json,
+    RowIndex: import_smithy_client.expectInt32,
+    RowSpan: import_smithy_client.expectInt32,
+    SelectionStatus: import_smithy_client.expectString,
+    Text: import_smithy_client.expectString,
+    TextType: import_smithy_client.expectString
+  });
+}, "de_Block");
+var de_BlockList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Block(entry, context);
+  });
+  return retVal;
+}, "de_BlockList");
+var de_BoundingBox = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Height: import_smithy_client.limitedParseFloat32,
+    Left: import_smithy_client.limitedParseFloat32,
+    Top: import_smithy_client.limitedParseFloat32,
+    Width: import_smithy_client.limitedParseFloat32
+  });
+}, "de_BoundingBox");
+var de_DetectDocumentTextResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Blocks: (_) => de_BlockList(_, context),
+    DetectDocumentTextModelVersion: import_smithy_client.expectString,
+    DocumentMetadata: import_smithy_client._json
+  });
+}, "de_DetectDocumentTextResponse");
+var de_EvaluationMetric = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    F1Score: import_smithy_client.limitedParseFloat32,
+    Precision: import_smithy_client.limitedParseFloat32,
+    Recall: import_smithy_client.limitedParseFloat32
+  });
+}, "de_EvaluationMetric");
+var de_ExpenseCurrency = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Code: import_smithy_client.expectString,
+    Confidence: import_smithy_client.limitedParseFloat32
+  });
+}, "de_ExpenseCurrency");
+var de_ExpenseDetection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    Geometry: (_) => de_Geometry(_, context),
+    Text: import_smithy_client.expectString
+  });
+}, "de_ExpenseDetection");
+var de_ExpenseDocument = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Blocks: (_) => de_BlockList(_, context),
+    ExpenseIndex: import_smithy_client.expectInt32,
+    LineItemGroups: (_) => de_LineItemGroupList(_, context),
+    SummaryFields: (_) => de_ExpenseFieldList(_, context)
+  });
+}, "de_ExpenseDocument");
+var de_ExpenseDocumentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExpenseDocument(entry, context);
+  });
+  return retVal;
+}, "de_ExpenseDocumentList");
+var de_ExpenseField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Currency: (_) => de_ExpenseCurrency(_, context),
+    GroupProperties: import_smithy_client._json,
+    LabelDetection: (_) => de_ExpenseDetection(_, context),
+    PageNumber: import_smithy_client.expectInt32,
+    Type: (_) => de_ExpenseType(_, context),
+    ValueDetection: (_) => de_ExpenseDetection(_, context)
+  });
+}, "de_ExpenseField");
+var de_ExpenseFieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExpenseField(entry, context);
+  });
+  return retVal;
+}, "de_ExpenseFieldList");
+var de_ExpenseType = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    Text: import_smithy_client.expectString
+  });
+}, "de_ExpenseType");
+var de_Extraction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ExpenseDocument: (_) => de_ExpenseDocument(_, context),
+    IdentityDocument: (_) => de_IdentityDocument(_, context),
+    LendingDocument: (_) => de_LendingDocument(_, context)
+  });
+}, "de_Extraction");
+var de_ExtractionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Extraction(entry, context);
+  });
+  return retVal;
+}, "de_ExtractionList");
+var de_Geometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BoundingBox: (_) => de_BoundingBox(_, context),
+    Polygon: (_) => de_Polygon(_, context)
+  });
+}, "de_Geometry");
+var de_GetAdapterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterId: import_smithy_client.expectString,
+    AdapterName: import_smithy_client.expectString,
+    AutoUpdate: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    FeatureTypes: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+}, "de_GetAdapterResponse");
+var de_GetAdapterVersionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterId: import_smithy_client.expectString,
+    AdapterVersion: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DatasetConfig: import_smithy_client._json,
+    EvaluationMetrics: (_) => de_AdapterVersionEvaluationMetrics(_, context),
+    FeatureTypes: import_smithy_client._json,
+    KMSKeyId: import_smithy_client.expectString,
+    OutputConfig: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_GetAdapterVersionResponse");
+var de_GetDocumentAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalyzeDocumentModelVersion: import_smithy_client.expectString,
+    Blocks: (_) => de_BlockList(_, context),
+    DocumentMetadata: import_smithy_client._json,
+    JobStatus: import_smithy_client.expectString,
+    NextToken: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString,
+    Warnings: import_smithy_client._json
+  });
+}, "de_GetDocumentAnalysisResponse");
+var de_GetDocumentTextDetectionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Blocks: (_) => de_BlockList(_, context),
+    DetectDocumentTextModelVersion: import_smithy_client.expectString,
+    DocumentMetadata: import_smithy_client._json,
+    JobStatus: import_smithy_client.expectString,
+    NextToken: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString,
+    Warnings: import_smithy_client._json
+  });
+}, "de_GetDocumentTextDetectionResponse");
+var de_GetExpenseAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalyzeExpenseModelVersion: import_smithy_client.expectString,
+    DocumentMetadata: import_smithy_client._json,
+    ExpenseDocuments: (_) => de_ExpenseDocumentList(_, context),
+    JobStatus: import_smithy_client.expectString,
+    NextToken: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString,
+    Warnings: import_smithy_client._json
+  });
+}, "de_GetExpenseAnalysisResponse");
+var de_GetLendingAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalyzeLendingModelVersion: import_smithy_client.expectString,
+    DocumentMetadata: import_smithy_client._json,
+    JobStatus: import_smithy_client.expectString,
+    NextToken: import_smithy_client.expectString,
+    Results: (_) => de_LendingResultList(_, context),
+    StatusMessage: import_smithy_client.expectString,
+    Warnings: import_smithy_client._json
+  });
+}, "de_GetLendingAnalysisResponse");
+var de_HumanLoopActivationOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HumanLoopActivationConditionsEvaluationResults: (_) => new import_smithy_client.LazyJsonString(_),
+    HumanLoopActivationReasons: import_smithy_client._json,
+    HumanLoopArn: import_smithy_client.expectString
+  });
+}, "de_HumanLoopActivationOutput");
+var de_IdentityDocument = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Blocks: (_) => de_BlockList(_, context),
+    DocumentIndex: import_smithy_client.expectInt32,
+    IdentityDocumentFields: (_) => de_IdentityDocumentFieldList(_, context)
+  });
+}, "de_IdentityDocument");
+var de_IdentityDocumentField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Type: (_) => de_AnalyzeIDDetections(_, context),
+    ValueDetection: (_) => de_AnalyzeIDDetections(_, context)
+  });
+}, "de_IdentityDocumentField");
+var de_IdentityDocumentFieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IdentityDocumentField(entry, context);
+  });
+  return retVal;
+}, "de_IdentityDocumentFieldList");
+var de_IdentityDocumentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IdentityDocument(entry, context);
+  });
+  return retVal;
+}, "de_IdentityDocumentList");
+var de_LendingDetection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    Geometry: (_) => de_Geometry(_, context),
+    SelectionStatus: import_smithy_client.expectString,
+    Text: import_smithy_client.expectString
+  });
+}, "de_LendingDetection");
+var de_LendingDetectionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LendingDetection(entry, context);
+  });
+  return retVal;
+}, "de_LendingDetectionList");
+var de_LendingDocument = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LendingFields: (_) => de_LendingFieldList(_, context),
+    SignatureDetections: (_) => de_SignatureDetectionList(_, context)
+  });
+}, "de_LendingDocument");
+var de_LendingField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    KeyDetection: (_) => de_LendingDetection(_, context),
+    Type: import_smithy_client.expectString,
+    ValueDetections: (_) => de_LendingDetectionList(_, context)
+  });
+}, "de_LendingField");
+var de_LendingFieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LendingField(entry, context);
+  });
+  return retVal;
+}, "de_LendingFieldList");
+var de_LendingResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Extractions: (_) => de_ExtractionList(_, context),
+    Page: import_smithy_client.expectInt32,
+    PageClassification: (_) => de_PageClassification(_, context)
+  });
+}, "de_LendingResult");
+var de_LendingResultList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LendingResult(entry, context);
+  });
+  return retVal;
+}, "de_LendingResultList");
+var de_LineItemFields = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LineItemExpenseFields: (_) => de_ExpenseFieldList(_, context)
+  });
+}, "de_LineItemFields");
+var de_LineItemGroup = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LineItemGroupIndex: import_smithy_client.expectInt32,
+    LineItems: (_) => de_LineItemList(_, context)
+  });
+}, "de_LineItemGroup");
+var de_LineItemGroupList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LineItemGroup(entry, context);
+  });
+  return retVal;
+}, "de_LineItemGroupList");
+var de_LineItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LineItemFields(entry, context);
+  });
+  return retVal;
+}, "de_LineItemList");
+var de_ListAdaptersResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Adapters: (_) => de_AdapterList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListAdaptersResponse");
+var de_ListAdapterVersionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterVersions: (_) => de_AdapterVersionList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListAdapterVersionsResponse");
+var de_PageClassification = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    PageNumber: (_) => de_PredictionList(_, context),
+    PageType: (_) => de_PredictionList(_, context)
+  });
+}, "de_PageClassification");
+var de_Point = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    X: import_smithy_client.limitedParseFloat32,
+    Y: import_smithy_client.limitedParseFloat32
+  });
+}, "de_Point");
+var de_Polygon = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Point(entry, context);
+  });
+  return retVal;
+}, "de_Polygon");
+var de_Prediction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    Value: import_smithy_client.expectString
+  });
+}, "de_Prediction");
+var de_PredictionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Prediction(entry, context);
+  });
+  return retVal;
+}, "de_PredictionList");
+var de_SignatureDetection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseFloat32,
+    Geometry: (_) => de_Geometry(_, context)
+  });
+}, "de_SignatureDetection");
+var de_SignatureDetectionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SignatureDetection(entry, context);
+  });
+  return retVal;
+}, "de_SignatureDetectionList");
+var de_UpdateAdapterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdapterId: import_smithy_client.expectString,
+    AdapterName: import_smithy_client.expectString,
+    AutoUpdate: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    FeatureTypes: import_smithy_client._json
+  });
+}, "de_UpdateAdapterResponse");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(TextractServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `Textract.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+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/AnalyzeDocumentCommand.ts
+var _AnalyzeDocumentCommand = class _AnalyzeDocumentCommand 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("Textract", "AnalyzeDocument", {}).n("TextractClient", "AnalyzeDocumentCommand").f(void 0, void 0).ser(se_AnalyzeDocumentCommand).de(de_AnalyzeDocumentCommand).build() {
+};
+__name(_AnalyzeDocumentCommand, "AnalyzeDocumentCommand");
+var AnalyzeDocumentCommand = _AnalyzeDocumentCommand;
+
+// src/commands/AnalyzeExpenseCommand.ts
+
+
+
+
+var _AnalyzeExpenseCommand = class _AnalyzeExpenseCommand 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("Textract", "AnalyzeExpense", {}).n("TextractClient", "AnalyzeExpenseCommand").f(void 0, void 0).ser(se_AnalyzeExpenseCommand).de(de_AnalyzeExpenseCommand).build() {
+};
+__name(_AnalyzeExpenseCommand, "AnalyzeExpenseCommand");
+var AnalyzeExpenseCommand = _AnalyzeExpenseCommand;
+
+// src/commands/AnalyzeIDCommand.ts
+
+
+
+
+var _AnalyzeIDCommand = class _AnalyzeIDCommand 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("Textract", "AnalyzeID", {}).n("TextractClient", "AnalyzeIDCommand").f(void 0, void 0).ser(se_AnalyzeIDCommand).de(de_AnalyzeIDCommand).build() {
+};
+__name(_AnalyzeIDCommand, "AnalyzeIDCommand");
+var AnalyzeIDCommand = _AnalyzeIDCommand;
+
+// src/commands/CreateAdapterCommand.ts
+
+
+
+
+var _CreateAdapterCommand = class _CreateAdapterCommand 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("Textract", "CreateAdapter", {}).n("TextractClient", "CreateAdapterCommand").f(void 0, void 0).ser(se_CreateAdapterCommand).de(de_CreateAdapterCommand).build() {
+};
+__name(_CreateAdapterCommand, "CreateAdapterCommand");
+var CreateAdapterCommand = _CreateAdapterCommand;
+
+// src/commands/CreateAdapterVersionCommand.ts
+
+
+
+
+var _CreateAdapterVersionCommand = class _CreateAdapterVersionCommand 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("Textract", "CreateAdapterVersion", {}).n("TextractClient", "CreateAdapterVersionCommand").f(void 0, void 0).ser(se_CreateAdapterVersionCommand).de(de_CreateAdapterVersionCommand).build() {
+};
+__name(_CreateAdapterVersionCommand, "CreateAdapterVersionCommand");
+var CreateAdapterVersionCommand = _CreateAdapterVersionCommand;
+
+// src/commands/DeleteAdapterCommand.ts
+
+
+
+
+var _DeleteAdapterCommand = class _DeleteAdapterCommand 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("Textract", "DeleteAdapter", {}).n("TextractClient", "DeleteAdapterCommand").f(void 0, void 0).ser(se_DeleteAdapterCommand).de(de_DeleteAdapterCommand).build() {
+};
+__name(_DeleteAdapterCommand, "DeleteAdapterCommand");
+var DeleteAdapterCommand = _DeleteAdapterCommand;
+
+// src/commands/DeleteAdapterVersionCommand.ts
+
+
+
+
+var _DeleteAdapterVersionCommand = class _DeleteAdapterVersionCommand 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("Textract", "DeleteAdapterVersion", {}).n("TextractClient", "DeleteAdapterVersionCommand").f(void 0, void 0).ser(se_DeleteAdapterVersionCommand).de(de_DeleteAdapterVersionCommand).build() {
+};
+__name(_DeleteAdapterVersionCommand, "DeleteAdapterVersionCommand");
+var DeleteAdapterVersionCommand = _DeleteAdapterVersionCommand;
+
+// src/commands/DetectDocumentTextCommand.ts
+
+
+
+
+var _DetectDocumentTextCommand = class _DetectDocumentTextCommand 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("Textract", "DetectDocumentText", {}).n("TextractClient", "DetectDocumentTextCommand").f(void 0, void 0).ser(se_DetectDocumentTextCommand).de(de_DetectDocumentTextCommand).build() {
+};
+__name(_DetectDocumentTextCommand, "DetectDocumentTextCommand");
+var DetectDocumentTextCommand = _DetectDocumentTextCommand;
+
+// src/commands/GetAdapterCommand.ts
+
+
+
+
+var _GetAdapterCommand = class _GetAdapterCommand 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("Textract", "GetAdapter", {}).n("TextractClient", "GetAdapterCommand").f(void 0, void 0).ser(se_GetAdapterCommand).de(de_GetAdapterCommand).build() {
+};
+__name(_GetAdapterCommand, "GetAdapterCommand");
+var GetAdapterCommand = _GetAdapterCommand;
+
+// src/commands/GetAdapterVersionCommand.ts
+
+
+
+
+var _GetAdapterVersionCommand = class _GetAdapterVersionCommand 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("Textract", "GetAdapterVersion", {}).n("TextractClient", "GetAdapterVersionCommand").f(void 0, void 0).ser(se_GetAdapterVersionCommand).de(de_GetAdapterVersionCommand).build() {
+};
+__name(_GetAdapterVersionCommand, "GetAdapterVersionCommand");
+var GetAdapterVersionCommand = _GetAdapterVersionCommand;
+
+// src/commands/GetDocumentAnalysisCommand.ts
+
+
+
+
+var _GetDocumentAnalysisCommand = class _GetDocumentAnalysisCommand 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("Textract", "GetDocumentAnalysis", {}).n("TextractClient", "GetDocumentAnalysisCommand").f(void 0, void 0).ser(se_GetDocumentAnalysisCommand).de(de_GetDocumentAnalysisCommand).build() {
+};
+__name(_GetDocumentAnalysisCommand, "GetDocumentAnalysisCommand");
+var GetDocumentAnalysisCommand = _GetDocumentAnalysisCommand;
+
+// src/commands/GetDocumentTextDetectionCommand.ts
+
+
+
+
+var _GetDocumentTextDetectionCommand = class _GetDocumentTextDetectionCommand 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("Textract", "GetDocumentTextDetection", {}).n("TextractClient", "GetDocumentTextDetectionCommand").f(void 0, void 0).ser(se_GetDocumentTextDetectionCommand).de(de_GetDocumentTextDetectionCommand).build() {
+};
+__name(_GetDocumentTextDetectionCommand, "GetDocumentTextDetectionCommand");
+var GetDocumentTextDetectionCommand = _GetDocumentTextDetectionCommand;
+
+// src/commands/GetExpenseAnalysisCommand.ts
+
+
+
+
+var _GetExpenseAnalysisCommand = class _GetExpenseAnalysisCommand 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("Textract", "GetExpenseAnalysis", {}).n("TextractClient", "GetExpenseAnalysisCommand").f(void 0, void 0).ser(se_GetExpenseAnalysisCommand).de(de_GetExpenseAnalysisCommand).build() {
+};
+__name(_GetExpenseAnalysisCommand, "GetExpenseAnalysisCommand");
+var GetExpenseAnalysisCommand = _GetExpenseAnalysisCommand;
+
+// src/commands/GetLendingAnalysisCommand.ts
+
+
+
+
+var _GetLendingAnalysisCommand = class _GetLendingAnalysisCommand 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("Textract", "GetLendingAnalysis", {}).n("TextractClient", "GetLendingAnalysisCommand").f(void 0, void 0).ser(se_GetLendingAnalysisCommand).de(de_GetLendingAnalysisCommand).build() {
+};
+__name(_GetLendingAnalysisCommand, "GetLendingAnalysisCommand");
+var GetLendingAnalysisCommand = _GetLendingAnalysisCommand;
+
+// src/commands/GetLendingAnalysisSummaryCommand.ts
+
+
+
+
+var _GetLendingAnalysisSummaryCommand = class _GetLendingAnalysisSummaryCommand 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("Textract", "GetLendingAnalysisSummary", {}).n("TextractClient", "GetLendingAnalysisSummaryCommand").f(void 0, void 0).ser(se_GetLendingAnalysisSummaryCommand).de(de_GetLendingAnalysisSummaryCommand).build() {
+};
+__name(_GetLendingAnalysisSummaryCommand, "GetLendingAnalysisSummaryCommand");
+var GetLendingAnalysisSummaryCommand = _GetLendingAnalysisSummaryCommand;
+
+// src/commands/ListAdaptersCommand.ts
+
+
+
+
+var _ListAdaptersCommand = class _ListAdaptersCommand 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("Textract", "ListAdapters", {}).n("TextractClient", "ListAdaptersCommand").f(void 0, void 0).ser(se_ListAdaptersCommand).de(de_ListAdaptersCommand).build() {
+};
+__name(_ListAdaptersCommand, "ListAdaptersCommand");
+var ListAdaptersCommand = _ListAdaptersCommand;
+
+// src/commands/ListAdapterVersionsCommand.ts
+
+
+
+
+var _ListAdapterVersionsCommand = class _ListAdapterVersionsCommand 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("Textract", "ListAdapterVersions", {}).n("TextractClient", "ListAdapterVersionsCommand").f(void 0, void 0).ser(se_ListAdapterVersionsCommand).de(de_ListAdapterVersionsCommand).build() {
+};
+__name(_ListAdapterVersionsCommand, "ListAdapterVersionsCommand");
+var ListAdapterVersionsCommand = _ListAdapterVersionsCommand;
+
+// 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("Textract", "ListTagsForResource", {}).n("TextractClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartDocumentAnalysisCommand.ts
+
+
+
+
+var _StartDocumentAnalysisCommand = class _StartDocumentAnalysisCommand 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("Textract", "StartDocumentAnalysis", {}).n("TextractClient", "StartDocumentAnalysisCommand").f(void 0, void 0).ser(se_StartDocumentAnalysisCommand).de(de_StartDocumentAnalysisCommand).build() {
+};
+__name(_StartDocumentAnalysisCommand, "StartDocumentAnalysisCommand");
+var StartDocumentAnalysisCommand = _StartDocumentAnalysisCommand;
+
+// src/commands/StartDocumentTextDetectionCommand.ts
+
+
+
+
+var _StartDocumentTextDetectionCommand = class _StartDocumentTextDetectionCommand 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("Textract", "StartDocumentTextDetection", {}).n("TextractClient", "StartDocumentTextDetectionCommand").f(void 0, void 0).ser(se_StartDocumentTextDetectionCommand).de(de_StartDocumentTextDetectionCommand).build() {
+};
+__name(_StartDocumentTextDetectionCommand, "StartDocumentTextDetectionCommand");
+var StartDocumentTextDetectionCommand = _StartDocumentTextDetectionCommand;
+
+// src/commands/StartExpenseAnalysisCommand.ts
+
+
+
+
+var _StartExpenseAnalysisCommand = class _StartExpenseAnalysisCommand 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("Textract", "StartExpenseAnalysis", {}).n("TextractClient", "StartExpenseAnalysisCommand").f(void 0, void 0).ser(se_StartExpenseAnalysisCommand).de(de_StartExpenseAnalysisCommand).build() {
+};
+__name(_StartExpenseAnalysisCommand, "StartExpenseAnalysisCommand");
+var StartExpenseAnalysisCommand = _StartExpenseAnalysisCommand;
+
+// src/commands/StartLendingAnalysisCommand.ts
+
+
+
+
+var _StartLendingAnalysisCommand = class _StartLendingAnalysisCommand 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("Textract", "StartLendingAnalysis", {}).n("TextractClient", "StartLendingAnalysisCommand").f(void 0, void 0).ser(se_StartLendingAnalysisCommand).de(de_StartLendingAnalysisCommand).build() {
+};
+__name(_StartLendingAnalysisCommand, "StartLendingAnalysisCommand");
+var StartLendingAnalysisCommand = _StartLendingAnalysisCommand;
+
+// 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("Textract", "TagResource", {}).n("TextractClient", "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("Textract", "UntagResource", {}).n("TextractClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateAdapterCommand.ts
+
+
+
+
+var _UpdateAdapterCommand = class _UpdateAdapterCommand 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("Textract", "UpdateAdapter", {}).n("TextractClient", "UpdateAdapterCommand").f(void 0, void 0).ser(se_UpdateAdapterCommand).de(de_UpdateAdapterCommand).build() {
+};
+__name(_UpdateAdapterCommand, "UpdateAdapterCommand");
+var UpdateAdapterCommand = _UpdateAdapterCommand;
+
+// src/Textract.ts
+var commands = {
+  AnalyzeDocumentCommand,
+  AnalyzeExpenseCommand,
+  AnalyzeIDCommand,
+  CreateAdapterCommand,
+  CreateAdapterVersionCommand,
+  DeleteAdapterCommand,
+  DeleteAdapterVersionCommand,
+  DetectDocumentTextCommand,
+  GetAdapterCommand,
+  GetAdapterVersionCommand,
+  GetDocumentAnalysisCommand,
+  GetDocumentTextDetectionCommand,
+  GetExpenseAnalysisCommand,
+  GetLendingAnalysisCommand,
+  GetLendingAnalysisSummaryCommand,
+  ListAdaptersCommand,
+  ListAdapterVersionsCommand,
+  ListTagsForResourceCommand,
+  StartDocumentAnalysisCommand,
+  StartDocumentTextDetectionCommand,
+  StartExpenseAnalysisCommand,
+  StartLendingAnalysisCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateAdapterCommand
+};
+var _Textract = class _Textract extends TextractClient {
+};
+__name(_Textract, "Textract");
+var Textract = _Textract;
+(0, import_smithy_client.createAggregatedClient)(commands, Textract);
+
+// src/pagination/ListAdapterVersionsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListAdapterVersions = (0, import_core.createPaginator)(TextractClient, ListAdapterVersionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListAdaptersPaginator.ts
+
+var paginateListAdapters = (0, import_core.createPaginator)(TextractClient, ListAdaptersCommand, "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,
+  AdapterVersionStatus,
+  AnalyzeDocumentCommand,
+  AnalyzeExpenseCommand,
+  AnalyzeIDCommand,
+  AutoUpdate,
+  BadDocumentException,
+  BlockType,
+  ConflictException,
+  ContentClassifier,
+  CreateAdapterCommand,
+  CreateAdapterVersionCommand,
+  DeleteAdapterCommand,
+  DeleteAdapterVersionCommand,
+  DetectDocumentTextCommand,
+  DocumentTooLargeException,
+  EntityType,
+  FeatureType,
+  GetAdapterCommand,
+  GetAdapterVersionCommand,
+  GetDocumentAnalysisCommand,
+  GetDocumentTextDetectionCommand,
+  GetExpenseAnalysisCommand,
+  GetLendingAnalysisCommand,
+  GetLendingAnalysisSummaryCommand,
+  HumanLoopQuotaExceededException,
+  IdempotentParameterMismatchException,
+  InternalServerError,
+  InvalidJobIdException,
+  InvalidKMSKeyException,
+  InvalidParameterException,
+  InvalidS3ObjectException,
+  JobStatus,
+  LimitExceededException,
+  ListAdapterVersionsCommand,
+  ListAdaptersCommand,
+  ListTagsForResourceCommand,
+  ProvisionedThroughputExceededException,
+  RelationshipType,
+  ResourceNotFoundException,
+  SelectionStatus,
+  ServiceQuotaExceededException,
+  StartDocumentAnalysisCommand,
+  StartDocumentTextDetectionCommand,
+  StartExpenseAnalysisCommand,
+  StartLendingAnalysisCommand,
+  TagResourceCommand,
+  TextType,
+  Textract,
+  TextractClient,
+  TextractServiceException,
+  ThrottlingException,
+  UnsupportedDocumentException,
+  UntagResourceCommand,
+  UpdateAdapterCommand,
+  ValidationException,
+  ValueType,
+  __Client,
+  paginateListAdapterVersions,
+  paginateListAdapters
+});
+