@aws-sdk/client-textract 3.901.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +2234 -2413
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,2474 +1,2295 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- AdapterVersionStatus: () => AdapterVersionStatus,
26
- AnalyzeDocumentCommand: () => AnalyzeDocumentCommand,
27
- AnalyzeExpenseCommand: () => AnalyzeExpenseCommand,
28
- AnalyzeIDCommand: () => AnalyzeIDCommand,
29
- AutoUpdate: () => AutoUpdate,
30
- BadDocumentException: () => BadDocumentException,
31
- BlockType: () => BlockType,
32
- ConflictException: () => ConflictException,
33
- ContentClassifier: () => ContentClassifier,
34
- CreateAdapterCommand: () => CreateAdapterCommand,
35
- CreateAdapterVersionCommand: () => CreateAdapterVersionCommand,
36
- DeleteAdapterCommand: () => DeleteAdapterCommand,
37
- DeleteAdapterVersionCommand: () => DeleteAdapterVersionCommand,
38
- DetectDocumentTextCommand: () => DetectDocumentTextCommand,
39
- DocumentTooLargeException: () => DocumentTooLargeException,
40
- EntityType: () => EntityType,
41
- FeatureType: () => FeatureType,
42
- GetAdapterCommand: () => GetAdapterCommand,
43
- GetAdapterVersionCommand: () => GetAdapterVersionCommand,
44
- GetDocumentAnalysisCommand: () => GetDocumentAnalysisCommand,
45
- GetDocumentTextDetectionCommand: () => GetDocumentTextDetectionCommand,
46
- GetExpenseAnalysisCommand: () => GetExpenseAnalysisCommand,
47
- GetLendingAnalysisCommand: () => GetLendingAnalysisCommand,
48
- GetLendingAnalysisSummaryCommand: () => GetLendingAnalysisSummaryCommand,
49
- HumanLoopQuotaExceededException: () => HumanLoopQuotaExceededException,
50
- IdempotentParameterMismatchException: () => IdempotentParameterMismatchException,
51
- InternalServerError: () => InternalServerError,
52
- InvalidJobIdException: () => InvalidJobIdException,
53
- InvalidKMSKeyException: () => InvalidKMSKeyException,
54
- InvalidParameterException: () => InvalidParameterException,
55
- InvalidS3ObjectException: () => InvalidS3ObjectException,
56
- JobStatus: () => JobStatus,
57
- LimitExceededException: () => LimitExceededException,
58
- ListAdapterVersionsCommand: () => ListAdapterVersionsCommand,
59
- ListAdaptersCommand: () => ListAdaptersCommand,
60
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
61
- ProvisionedThroughputExceededException: () => ProvisionedThroughputExceededException,
62
- RelationshipType: () => RelationshipType,
63
- ResourceNotFoundException: () => ResourceNotFoundException,
64
- SelectionStatus: () => SelectionStatus,
65
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
66
- StartDocumentAnalysisCommand: () => StartDocumentAnalysisCommand,
67
- StartDocumentTextDetectionCommand: () => StartDocumentTextDetectionCommand,
68
- StartExpenseAnalysisCommand: () => StartExpenseAnalysisCommand,
69
- StartLendingAnalysisCommand: () => StartLendingAnalysisCommand,
70
- TagResourceCommand: () => TagResourceCommand,
71
- TextType: () => TextType,
72
- Textract: () => Textract,
73
- TextractClient: () => TextractClient,
74
- TextractServiceException: () => TextractServiceException,
75
- ThrottlingException: () => ThrottlingException,
76
- UnsupportedDocumentException: () => UnsupportedDocumentException,
77
- UntagResourceCommand: () => UntagResourceCommand,
78
- UpdateAdapterCommand: () => UpdateAdapterCommand,
79
- ValidationException: () => ValidationException,
80
- ValueType: () => ValueType,
81
- __Client: () => import_smithy_client.Client,
82
- paginateListAdapterVersions: () => paginateListAdapterVersions,
83
- paginateListAdapters: () => paginateListAdapters
84
- });
85
- module.exports = __toCommonJS(index_exports);
86
-
87
- // src/TextractClient.ts
88
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
89
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
90
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
91
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
92
- var import_config_resolver = require("@smithy/config-resolver");
93
- var import_core = require("@smithy/core");
94
- var import_middleware_content_length = require("@smithy/middleware-content-length");
95
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
96
- var import_middleware_retry = require("@smithy/middleware-retry");
97
-
98
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
99
-
100
- // src/endpoint/EndpointParameters.ts
101
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
102
- return Object.assign(options, {
103
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
104
- useFipsEndpoint: options.useFipsEndpoint ?? false,
105
- defaultSigningName: "textract"
106
- });
107
- }, "resolveClientEndpointParameters");
108
- var commonParams = {
109
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
110
- Endpoint: { type: "builtInParams", name: "endpoint" },
111
- Region: { type: "builtInParams", name: "region" },
112
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+ var uuid = require('@smithy/uuid');
20
+
21
+ const resolveClientEndpointParameters = (options) => {
22
+ return Object.assign(options, {
23
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
24
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
25
+ defaultSigningName: "textract",
26
+ });
27
+ };
28
+ const commonParams = {
29
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
30
+ Endpoint: { type: "builtInParams", name: "endpoint" },
31
+ Region: { type: "builtInParams", name: "region" },
32
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
113
33
  };
114
34
 
115
- // src/TextractClient.ts
116
- var import_runtimeConfig = require("././runtimeConfig");
35
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
36
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
37
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
38
+ let _credentials = runtimeConfig.credentials;
39
+ return {
40
+ setHttpAuthScheme(httpAuthScheme) {
41
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
42
+ if (index === -1) {
43
+ _httpAuthSchemes.push(httpAuthScheme);
44
+ }
45
+ else {
46
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
47
+ }
48
+ },
49
+ httpAuthSchemes() {
50
+ return _httpAuthSchemes;
51
+ },
52
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
53
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
54
+ },
55
+ httpAuthSchemeProvider() {
56
+ return _httpAuthSchemeProvider;
57
+ },
58
+ setCredentials(credentials) {
59
+ _credentials = credentials;
60
+ },
61
+ credentials() {
62
+ return _credentials;
63
+ },
64
+ };
65
+ };
66
+ const resolveHttpAuthRuntimeConfig = (config) => {
67
+ return {
68
+ httpAuthSchemes: config.httpAuthSchemes(),
69
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
70
+ credentials: config.credentials(),
71
+ };
72
+ };
117
73
 
118
- // src/runtimeExtensions.ts
119
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
120
- var import_protocol_http = require("@smithy/protocol-http");
121
- var import_smithy_client = require("@smithy/smithy-client");
74
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
75
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
76
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
77
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
78
+ };
122
79
 
123
- // src/auth/httpAuthExtensionConfiguration.ts
124
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
125
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
126
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
127
- let _credentials = runtimeConfig.credentials;
128
- return {
129
- setHttpAuthScheme(httpAuthScheme) {
130
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
131
- if (index === -1) {
132
- _httpAuthSchemes.push(httpAuthScheme);
133
- } else {
134
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
135
- }
136
- },
137
- httpAuthSchemes() {
138
- return _httpAuthSchemes;
139
- },
140
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
141
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
142
- },
143
- httpAuthSchemeProvider() {
144
- return _httpAuthSchemeProvider;
145
- },
146
- setCredentials(credentials) {
147
- _credentials = credentials;
148
- },
149
- credentials() {
150
- return _credentials;
80
+ class TextractClient extends smithyClient.Client {
81
+ config;
82
+ constructor(...[configuration]) {
83
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
84
+ super(_config_0);
85
+ this.initConfig = _config_0;
86
+ const _config_1 = resolveClientEndpointParameters(_config_0);
87
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
88
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
89
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
90
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
91
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
92
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
93
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
94
+ this.config = _config_8;
95
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
96
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
98
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
99
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
100
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
101
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
102
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultTextractHttpAuthSchemeParametersProvider,
103
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
104
+ "aws.auth#sigv4": config.credentials,
105
+ }),
106
+ }));
107
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
151
108
  }
152
- };
153
- }, "getHttpAuthExtensionConfiguration");
154
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
155
- return {
156
- httpAuthSchemes: config.httpAuthSchemes(),
157
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
158
- credentials: config.credentials()
159
- };
160
- }, "resolveHttpAuthRuntimeConfig");
109
+ destroy() {
110
+ super.destroy();
111
+ }
112
+ }
161
113
 
162
- // src/runtimeExtensions.ts
163
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
164
- const extensionConfiguration = Object.assign(
165
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
166
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
167
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
168
- getHttpAuthExtensionConfiguration(runtimeConfig)
169
- );
170
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
171
- return Object.assign(
172
- runtimeConfig,
173
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
174
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
175
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
176
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
177
- );
178
- }, "resolveRuntimeExtensions");
114
+ class TextractServiceException extends smithyClient.ServiceException {
115
+ constructor(options) {
116
+ super(options);
117
+ Object.setPrototypeOf(this, TextractServiceException.prototype);
118
+ }
119
+ }
179
120
 
180
- // src/TextractClient.ts
181
- var TextractClient = class extends import_smithy_client.Client {
182
- static {
183
- __name(this, "TextractClient");
184
- }
185
- /**
186
- * The resolved configuration of TextractClient class. This is resolved and normalized from the {@link TextractClientConfig | constructor configuration interface}.
187
- */
188
- config;
189
- constructor(...[configuration]) {
190
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
191
- super(_config_0);
192
- this.initConfig = _config_0;
193
- const _config_1 = resolveClientEndpointParameters(_config_0);
194
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
195
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
196
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
197
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
198
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
199
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
200
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
201
- this.config = _config_8;
202
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
203
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
204
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
205
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
206
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
207
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
208
- this.middlewareStack.use(
209
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
210
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultTextractHttpAuthSchemeParametersProvider,
211
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
212
- "aws.auth#sigv4": config.credentials
213
- }), "identityProviderConfigProvider")
214
- })
215
- );
216
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
217
- }
218
- /**
219
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
220
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
221
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
222
- */
223
- destroy() {
224
- super.destroy();
225
- }
121
+ class AccessDeniedException extends TextractServiceException {
122
+ name = "AccessDeniedException";
123
+ $fault = "client";
124
+ Message;
125
+ Code;
126
+ constructor(opts) {
127
+ super({
128
+ name: "AccessDeniedException",
129
+ $fault: "client",
130
+ ...opts,
131
+ });
132
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
133
+ this.Message = opts.Message;
134
+ this.Code = opts.Code;
135
+ }
136
+ }
137
+ const FeatureType = {
138
+ FORMS: "FORMS",
139
+ LAYOUT: "LAYOUT",
140
+ QUERIES: "QUERIES",
141
+ SIGNATURES: "SIGNATURES",
142
+ TABLES: "TABLES",
226
143
  };
227
-
228
- // src/Textract.ts
229
-
230
-
231
- // src/commands/AnalyzeDocumentCommand.ts
232
-
233
- var import_middleware_serde = require("@smithy/middleware-serde");
234
-
235
-
236
- // src/protocols/Aws_json1_1.ts
237
- var import_core2 = require("@aws-sdk/core");
238
-
239
-
240
- var import_uuid = require("@smithy/uuid");
241
-
242
- // src/models/TextractServiceException.ts
243
-
244
- var TextractServiceException = class _TextractServiceException extends import_smithy_client.ServiceException {
245
- static {
246
- __name(this, "TextractServiceException");
247
- }
248
- /**
249
- * @internal
250
- */
251
- constructor(options) {
252
- super(options);
253
- Object.setPrototypeOf(this, _TextractServiceException.prototype);
254
- }
144
+ const AdapterVersionStatus = {
145
+ ACTIVE: "ACTIVE",
146
+ AT_RISK: "AT_RISK",
147
+ CREATION_ERROR: "CREATION_ERROR",
148
+ CREATION_IN_PROGRESS: "CREATION_IN_PROGRESS",
149
+ DEPRECATED: "DEPRECATED",
255
150
  };
256
-
257
- // src/models/models_0.ts
258
- var AccessDeniedException = class _AccessDeniedException extends TextractServiceException {
259
- static {
260
- __name(this, "AccessDeniedException");
261
- }
262
- name = "AccessDeniedException";
263
- $fault = "client";
264
- Message;
265
- Code;
266
- /**
267
- * @internal
268
- */
269
- constructor(opts) {
270
- super({
271
- name: "AccessDeniedException",
272
- $fault: "client",
273
- ...opts
274
- });
275
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
276
- this.Message = opts.Message;
277
- this.Code = opts.Code;
278
- }
279
- };
280
- var FeatureType = {
281
- FORMS: "FORMS",
282
- LAYOUT: "LAYOUT",
283
- QUERIES: "QUERIES",
284
- SIGNATURES: "SIGNATURES",
285
- TABLES: "TABLES"
286
- };
287
- var AdapterVersionStatus = {
288
- ACTIVE: "ACTIVE",
289
- AT_RISK: "AT_RISK",
290
- CREATION_ERROR: "CREATION_ERROR",
291
- CREATION_IN_PROGRESS: "CREATION_IN_PROGRESS",
292
- DEPRECATED: "DEPRECATED"
293
- };
294
- var ContentClassifier = {
295
- FREE_OF_ADULT_CONTENT: "FreeOfAdultContent",
296
- FREE_OF_PERSONALLY_IDENTIFIABLE_INFORMATION: "FreeOfPersonallyIdentifiableInformation"
297
- };
298
- var BlockType = {
299
- CELL: "CELL",
300
- KEY_VALUE_SET: "KEY_VALUE_SET",
301
- LAYOUT_FIGURE: "LAYOUT_FIGURE",
302
- LAYOUT_FOOTER: "LAYOUT_FOOTER",
303
- LAYOUT_HEADER: "LAYOUT_HEADER",
304
- LAYOUT_KEY_VALUE: "LAYOUT_KEY_VALUE",
305
- LAYOUT_LIST: "LAYOUT_LIST",
306
- LAYOUT_PAGE_NUMBER: "LAYOUT_PAGE_NUMBER",
307
- LAYOUT_SECTION_HEADER: "LAYOUT_SECTION_HEADER",
308
- LAYOUT_TABLE: "LAYOUT_TABLE",
309
- LAYOUT_TEXT: "LAYOUT_TEXT",
310
- LAYOUT_TITLE: "LAYOUT_TITLE",
311
- LINE: "LINE",
312
- MERGED_CELL: "MERGED_CELL",
313
- PAGE: "PAGE",
314
- QUERY: "QUERY",
315
- QUERY_RESULT: "QUERY_RESULT",
316
- SELECTION_ELEMENT: "SELECTION_ELEMENT",
317
- SIGNATURE: "SIGNATURE",
318
- TABLE: "TABLE",
319
- TABLE_FOOTER: "TABLE_FOOTER",
320
- TABLE_TITLE: "TABLE_TITLE",
321
- TITLE: "TITLE",
322
- WORD: "WORD"
323
- };
324
- var EntityType = {
325
- COLUMN_HEADER: "COLUMN_HEADER",
326
- KEY: "KEY",
327
- SEMI_STRUCTURED_TABLE: "SEMI_STRUCTURED_TABLE",
328
- STRUCTURED_TABLE: "STRUCTURED_TABLE",
329
- TABLE_FOOTER: "TABLE_FOOTER",
330
- TABLE_SECTION_TITLE: "TABLE_SECTION_TITLE",
331
- TABLE_SUMMARY: "TABLE_SUMMARY",
332
- TABLE_TITLE: "TABLE_TITLE",
333
- VALUE: "VALUE"
334
- };
335
- var RelationshipType = {
336
- ANSWER: "ANSWER",
337
- CHILD: "CHILD",
338
- COMPLEX_FEATURES: "COMPLEX_FEATURES",
339
- MERGED_CELL: "MERGED_CELL",
340
- TABLE: "TABLE",
341
- TABLE_FOOTER: "TABLE_FOOTER",
342
- TABLE_TITLE: "TABLE_TITLE",
343
- TITLE: "TITLE",
344
- VALUE: "VALUE"
345
- };
346
- var SelectionStatus = {
347
- NOT_SELECTED: "NOT_SELECTED",
348
- SELECTED: "SELECTED"
349
- };
350
- var TextType = {
351
- HANDWRITING: "HANDWRITING",
352
- PRINTED: "PRINTED"
353
- };
354
- var BadDocumentException = class _BadDocumentException extends TextractServiceException {
355
- static {
356
- __name(this, "BadDocumentException");
357
- }
358
- name = "BadDocumentException";
359
- $fault = "client";
360
- Message;
361
- Code;
362
- /**
363
- * @internal
364
- */
365
- constructor(opts) {
366
- super({
367
- name: "BadDocumentException",
368
- $fault: "client",
369
- ...opts
370
- });
371
- Object.setPrototypeOf(this, _BadDocumentException.prototype);
372
- this.Message = opts.Message;
373
- this.Code = opts.Code;
374
- }
375
- };
376
- var DocumentTooLargeException = class _DocumentTooLargeException extends TextractServiceException {
377
- static {
378
- __name(this, "DocumentTooLargeException");
379
- }
380
- name = "DocumentTooLargeException";
381
- $fault = "client";
382
- Message;
383
- Code;
384
- /**
385
- * @internal
386
- */
387
- constructor(opts) {
388
- super({
389
- name: "DocumentTooLargeException",
390
- $fault: "client",
391
- ...opts
392
- });
393
- Object.setPrototypeOf(this, _DocumentTooLargeException.prototype);
394
- this.Message = opts.Message;
395
- this.Code = opts.Code;
396
- }
397
- };
398
- var HumanLoopQuotaExceededException = class _HumanLoopQuotaExceededException extends TextractServiceException {
399
- static {
400
- __name(this, "HumanLoopQuotaExceededException");
401
- }
402
- name = "HumanLoopQuotaExceededException";
403
- $fault = "client";
404
- /**
405
- * <p>The resource type.</p>
406
- * @public
407
- */
408
- ResourceType;
409
- /**
410
- * <p>The quota code.</p>
411
- * @public
412
- */
413
- QuotaCode;
414
- /**
415
- * <p>The service code.</p>
416
- * @public
417
- */
418
- ServiceCode;
419
- Message;
420
- Code;
421
- /**
422
- * @internal
423
- */
424
- constructor(opts) {
425
- super({
426
- name: "HumanLoopQuotaExceededException",
427
- $fault: "client",
428
- ...opts
429
- });
430
- Object.setPrototypeOf(this, _HumanLoopQuotaExceededException.prototype);
431
- this.ResourceType = opts.ResourceType;
432
- this.QuotaCode = opts.QuotaCode;
433
- this.ServiceCode = opts.ServiceCode;
434
- this.Message = opts.Message;
435
- this.Code = opts.Code;
436
- }
437
- };
438
- var InternalServerError = class _InternalServerError extends TextractServiceException {
439
- static {
440
- __name(this, "InternalServerError");
441
- }
442
- name = "InternalServerError";
443
- $fault = "server";
444
- Message;
445
- Code;
446
- /**
447
- * @internal
448
- */
449
- constructor(opts) {
450
- super({
451
- name: "InternalServerError",
452
- $fault: "server",
453
- ...opts
454
- });
455
- Object.setPrototypeOf(this, _InternalServerError.prototype);
456
- this.Message = opts.Message;
457
- this.Code = opts.Code;
458
- }
459
- };
460
- var InvalidParameterException = class _InvalidParameterException extends TextractServiceException {
461
- static {
462
- __name(this, "InvalidParameterException");
463
- }
464
- name = "InvalidParameterException";
465
- $fault = "client";
466
- Message;
467
- Code;
468
- /**
469
- * @internal
470
- */
471
- constructor(opts) {
472
- super({
473
- name: "InvalidParameterException",
474
- $fault: "client",
475
- ...opts
476
- });
477
- Object.setPrototypeOf(this, _InvalidParameterException.prototype);
478
- this.Message = opts.Message;
479
- this.Code = opts.Code;
480
- }
481
- };
482
- var InvalidS3ObjectException = class _InvalidS3ObjectException extends TextractServiceException {
483
- static {
484
- __name(this, "InvalidS3ObjectException");
485
- }
486
- name = "InvalidS3ObjectException";
487
- $fault = "client";
488
- Message;
489
- Code;
490
- /**
491
- * @internal
492
- */
493
- constructor(opts) {
494
- super({
495
- name: "InvalidS3ObjectException",
496
- $fault: "client",
497
- ...opts
498
- });
499
- Object.setPrototypeOf(this, _InvalidS3ObjectException.prototype);
500
- this.Message = opts.Message;
501
- this.Code = opts.Code;
502
- }
503
- };
504
- var ProvisionedThroughputExceededException = class _ProvisionedThroughputExceededException extends TextractServiceException {
505
- static {
506
- __name(this, "ProvisionedThroughputExceededException");
507
- }
508
- name = "ProvisionedThroughputExceededException";
509
- $fault = "client";
510
- Message;
511
- Code;
512
- /**
513
- * @internal
514
- */
515
- constructor(opts) {
516
- super({
517
- name: "ProvisionedThroughputExceededException",
518
- $fault: "client",
519
- ...opts
520
- });
521
- Object.setPrototypeOf(this, _ProvisionedThroughputExceededException.prototype);
522
- this.Message = opts.Message;
523
- this.Code = opts.Code;
524
- }
525
- };
526
- var ThrottlingException = class _ThrottlingException extends TextractServiceException {
527
- static {
528
- __name(this, "ThrottlingException");
529
- }
530
- name = "ThrottlingException";
531
- $fault = "server";
532
- Message;
533
- Code;
534
- /**
535
- * @internal
536
- */
537
- constructor(opts) {
538
- super({
539
- name: "ThrottlingException",
540
- $fault: "server",
541
- ...opts
542
- });
543
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
544
- this.Message = opts.Message;
545
- this.Code = opts.Code;
546
- }
547
- };
548
- var UnsupportedDocumentException = class _UnsupportedDocumentException extends TextractServiceException {
549
- static {
550
- __name(this, "UnsupportedDocumentException");
551
- }
552
- name = "UnsupportedDocumentException";
553
- $fault = "client";
554
- Message;
555
- Code;
556
- /**
557
- * @internal
558
- */
559
- constructor(opts) {
560
- super({
561
- name: "UnsupportedDocumentException",
562
- $fault: "client",
563
- ...opts
564
- });
565
- Object.setPrototypeOf(this, _UnsupportedDocumentException.prototype);
566
- this.Message = opts.Message;
567
- this.Code = opts.Code;
568
- }
569
- };
570
- var ValueType = {
571
- DATE: "DATE"
572
- };
573
- var AutoUpdate = {
574
- DISABLED: "DISABLED",
575
- ENABLED: "ENABLED"
576
- };
577
- var ConflictException = class _ConflictException extends TextractServiceException {
578
- static {
579
- __name(this, "ConflictException");
580
- }
581
- name = "ConflictException";
582
- $fault = "client";
583
- Message;
584
- Code;
585
- /**
586
- * @internal
587
- */
588
- constructor(opts) {
589
- super({
590
- name: "ConflictException",
591
- $fault: "client",
592
- ...opts
593
- });
594
- Object.setPrototypeOf(this, _ConflictException.prototype);
595
- this.Message = opts.Message;
596
- this.Code = opts.Code;
597
- }
598
- };
599
- var IdempotentParameterMismatchException = class _IdempotentParameterMismatchException extends TextractServiceException {
600
- static {
601
- __name(this, "IdempotentParameterMismatchException");
602
- }
603
- name = "IdempotentParameterMismatchException";
604
- $fault = "client";
605
- Message;
606
- Code;
607
- /**
608
- * @internal
609
- */
610
- constructor(opts) {
611
- super({
612
- name: "IdempotentParameterMismatchException",
613
- $fault: "client",
614
- ...opts
615
- });
616
- Object.setPrototypeOf(this, _IdempotentParameterMismatchException.prototype);
617
- this.Message = opts.Message;
618
- this.Code = opts.Code;
619
- }
620
- };
621
- var LimitExceededException = class _LimitExceededException extends TextractServiceException {
622
- static {
623
- __name(this, "LimitExceededException");
624
- }
625
- name = "LimitExceededException";
626
- $fault = "client";
627
- Message;
628
- Code;
629
- /**
630
- * @internal
631
- */
632
- constructor(opts) {
633
- super({
634
- name: "LimitExceededException",
635
- $fault: "client",
636
- ...opts
637
- });
638
- Object.setPrototypeOf(this, _LimitExceededException.prototype);
639
- this.Message = opts.Message;
640
- this.Code = opts.Code;
641
- }
642
- };
643
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends TextractServiceException {
644
- static {
645
- __name(this, "ServiceQuotaExceededException");
646
- }
647
- name = "ServiceQuotaExceededException";
648
- $fault = "client";
649
- Message;
650
- Code;
651
- /**
652
- * @internal
653
- */
654
- constructor(opts) {
655
- super({
656
- name: "ServiceQuotaExceededException",
657
- $fault: "client",
658
- ...opts
659
- });
660
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
661
- this.Message = opts.Message;
662
- this.Code = opts.Code;
663
- }
664
- };
665
- var ValidationException = class _ValidationException extends TextractServiceException {
666
- static {
667
- __name(this, "ValidationException");
668
- }
669
- name = "ValidationException";
670
- $fault = "client";
671
- Message;
672
- Code;
673
- /**
674
- * @internal
675
- */
676
- constructor(opts) {
677
- super({
678
- name: "ValidationException",
679
- $fault: "client",
680
- ...opts
681
- });
682
- Object.setPrototypeOf(this, _ValidationException.prototype);
683
- this.Message = opts.Message;
684
- this.Code = opts.Code;
685
- }
686
- };
687
- var InvalidKMSKeyException = class _InvalidKMSKeyException extends TextractServiceException {
688
- static {
689
- __name(this, "InvalidKMSKeyException");
690
- }
691
- name = "InvalidKMSKeyException";
692
- $fault = "client";
693
- Message;
694
- Code;
695
- /**
696
- * @internal
697
- */
698
- constructor(opts) {
699
- super({
700
- name: "InvalidKMSKeyException",
701
- $fault: "client",
702
- ...opts
703
- });
704
- Object.setPrototypeOf(this, _InvalidKMSKeyException.prototype);
705
- this.Message = opts.Message;
706
- this.Code = opts.Code;
707
- }
708
- };
709
- var ResourceNotFoundException = class _ResourceNotFoundException extends TextractServiceException {
710
- static {
711
- __name(this, "ResourceNotFoundException");
712
- }
713
- name = "ResourceNotFoundException";
714
- $fault = "client";
715
- Message;
716
- Code;
717
- /**
718
- * @internal
719
- */
720
- constructor(opts) {
721
- super({
722
- name: "ResourceNotFoundException",
723
- $fault: "client",
724
- ...opts
725
- });
726
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
727
- this.Message = opts.Message;
728
- this.Code = opts.Code;
729
- }
730
- };
731
- var JobStatus = {
732
- FAILED: "FAILED",
733
- IN_PROGRESS: "IN_PROGRESS",
734
- PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
735
- SUCCEEDED: "SUCCEEDED"
736
- };
737
- var InvalidJobIdException = class _InvalidJobIdException extends TextractServiceException {
738
- static {
739
- __name(this, "InvalidJobIdException");
740
- }
741
- name = "InvalidJobIdException";
742
- $fault = "client";
743
- Message;
744
- Code;
745
- /**
746
- * @internal
747
- */
748
- constructor(opts) {
749
- super({
750
- name: "InvalidJobIdException",
751
- $fault: "client",
752
- ...opts
753
- });
754
- Object.setPrototypeOf(this, _InvalidJobIdException.prototype);
755
- this.Message = opts.Message;
756
- this.Code = opts.Code;
757
- }
151
+ const ContentClassifier = {
152
+ FREE_OF_ADULT_CONTENT: "FreeOfAdultContent",
153
+ FREE_OF_PERSONALLY_IDENTIFIABLE_INFORMATION: "FreeOfPersonallyIdentifiableInformation",
758
154
  };
759
-
760
- // src/protocols/Aws_json1_1.ts
761
- var se_AnalyzeDocumentCommand = /* @__PURE__ */ __name(async (input, context) => {
762
- const headers = sharedHeaders("AnalyzeDocument");
763
- let body;
764
- body = JSON.stringify(se_AnalyzeDocumentRequest(input, context));
765
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
766
- }, "se_AnalyzeDocumentCommand");
767
- var se_AnalyzeExpenseCommand = /* @__PURE__ */ __name(async (input, context) => {
768
- const headers = sharedHeaders("AnalyzeExpense");
769
- let body;
770
- body = JSON.stringify(se_AnalyzeExpenseRequest(input, context));
771
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
772
- }, "se_AnalyzeExpenseCommand");
773
- var se_AnalyzeIDCommand = /* @__PURE__ */ __name(async (input, context) => {
774
- const headers = sharedHeaders("AnalyzeID");
775
- let body;
776
- body = JSON.stringify(se_AnalyzeIDRequest(input, context));
777
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
778
- }, "se_AnalyzeIDCommand");
779
- var se_CreateAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
780
- const headers = sharedHeaders("CreateAdapter");
781
- let body;
782
- body = JSON.stringify(se_CreateAdapterRequest(input, context));
783
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
784
- }, "se_CreateAdapterCommand");
785
- var se_CreateAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
786
- const headers = sharedHeaders("CreateAdapterVersion");
787
- let body;
788
- body = JSON.stringify(se_CreateAdapterVersionRequest(input, context));
789
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
790
- }, "se_CreateAdapterVersionCommand");
791
- var se_DeleteAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
792
- const headers = sharedHeaders("DeleteAdapter");
793
- let body;
794
- body = JSON.stringify((0, import_smithy_client._json)(input));
795
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
796
- }, "se_DeleteAdapterCommand");
797
- var se_DeleteAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
798
- const headers = sharedHeaders("DeleteAdapterVersion");
799
- let body;
800
- body = JSON.stringify((0, import_smithy_client._json)(input));
801
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
802
- }, "se_DeleteAdapterVersionCommand");
803
- var se_DetectDocumentTextCommand = /* @__PURE__ */ __name(async (input, context) => {
804
- const headers = sharedHeaders("DetectDocumentText");
805
- let body;
806
- body = JSON.stringify(se_DetectDocumentTextRequest(input, context));
807
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
808
- }, "se_DetectDocumentTextCommand");
809
- var se_GetAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
810
- const headers = sharedHeaders("GetAdapter");
811
- let body;
812
- body = JSON.stringify((0, import_smithy_client._json)(input));
813
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
814
- }, "se_GetAdapterCommand");
815
- var se_GetAdapterVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
816
- const headers = sharedHeaders("GetAdapterVersion");
817
- let body;
818
- body = JSON.stringify((0, import_smithy_client._json)(input));
819
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
820
- }, "se_GetAdapterVersionCommand");
821
- var se_GetDocumentAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
822
- const headers = sharedHeaders("GetDocumentAnalysis");
823
- let body;
824
- body = JSON.stringify((0, import_smithy_client._json)(input));
825
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
826
- }, "se_GetDocumentAnalysisCommand");
827
- var se_GetDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (input, context) => {
828
- const headers = sharedHeaders("GetDocumentTextDetection");
829
- let body;
830
- body = JSON.stringify((0, import_smithy_client._json)(input));
831
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
832
- }, "se_GetDocumentTextDetectionCommand");
833
- var se_GetExpenseAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
834
- const headers = sharedHeaders("GetExpenseAnalysis");
835
- let body;
836
- body = JSON.stringify((0, import_smithy_client._json)(input));
837
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
838
- }, "se_GetExpenseAnalysisCommand");
839
- var se_GetLendingAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
840
- const headers = sharedHeaders("GetLendingAnalysis");
841
- let body;
842
- body = JSON.stringify((0, import_smithy_client._json)(input));
843
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
844
- }, "se_GetLendingAnalysisCommand");
845
- var se_GetLendingAnalysisSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {
846
- const headers = sharedHeaders("GetLendingAnalysisSummary");
847
- let body;
848
- body = JSON.stringify((0, import_smithy_client._json)(input));
849
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
850
- }, "se_GetLendingAnalysisSummaryCommand");
851
- var se_ListAdaptersCommand = /* @__PURE__ */ __name(async (input, context) => {
852
- const headers = sharedHeaders("ListAdapters");
853
- let body;
854
- body = JSON.stringify(se_ListAdaptersRequest(input, context));
855
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
856
- }, "se_ListAdaptersCommand");
857
- var se_ListAdapterVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
858
- const headers = sharedHeaders("ListAdapterVersions");
859
- let body;
860
- body = JSON.stringify(se_ListAdapterVersionsRequest(input, context));
861
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
862
- }, "se_ListAdapterVersionsCommand");
863
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
864
- const headers = sharedHeaders("ListTagsForResource");
865
- let body;
866
- body = JSON.stringify((0, import_smithy_client._json)(input));
867
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
868
- }, "se_ListTagsForResourceCommand");
869
- var se_StartDocumentAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
870
- const headers = sharedHeaders("StartDocumentAnalysis");
871
- let body;
872
- body = JSON.stringify((0, import_smithy_client._json)(input));
873
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
874
- }, "se_StartDocumentAnalysisCommand");
875
- var se_StartDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (input, context) => {
876
- const headers = sharedHeaders("StartDocumentTextDetection");
877
- let body;
878
- body = JSON.stringify((0, import_smithy_client._json)(input));
879
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
880
- }, "se_StartDocumentTextDetectionCommand");
881
- var se_StartExpenseAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
882
- const headers = sharedHeaders("StartExpenseAnalysis");
883
- let body;
884
- body = JSON.stringify((0, import_smithy_client._json)(input));
885
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
886
- }, "se_StartExpenseAnalysisCommand");
887
- var se_StartLendingAnalysisCommand = /* @__PURE__ */ __name(async (input, context) => {
888
- const headers = sharedHeaders("StartLendingAnalysis");
889
- let body;
890
- body = JSON.stringify((0, import_smithy_client._json)(input));
891
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
892
- }, "se_StartLendingAnalysisCommand");
893
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
894
- const headers = sharedHeaders("TagResource");
895
- let body;
896
- body = JSON.stringify((0, import_smithy_client._json)(input));
897
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
898
- }, "se_TagResourceCommand");
899
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
900
- const headers = sharedHeaders("UntagResource");
901
- let body;
902
- body = JSON.stringify((0, import_smithy_client._json)(input));
903
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
904
- }, "se_UntagResourceCommand");
905
- var se_UpdateAdapterCommand = /* @__PURE__ */ __name(async (input, context) => {
906
- const headers = sharedHeaders("UpdateAdapter");
907
- let body;
908
- body = JSON.stringify((0, import_smithy_client._json)(input));
909
- return buildHttpRpcRequest(context, headers, "/", void 0, body);
910
- }, "se_UpdateAdapterCommand");
911
- var de_AnalyzeDocumentCommand = /* @__PURE__ */ __name(async (output, context) => {
912
- if (output.statusCode >= 300) {
913
- return de_CommandError(output, context);
914
- }
915
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
916
- let contents = {};
917
- contents = de_AnalyzeDocumentResponse(data, context);
918
- const response = {
919
- $metadata: deserializeMetadata(output),
920
- ...contents
921
- };
922
- return response;
923
- }, "de_AnalyzeDocumentCommand");
924
- var de_AnalyzeExpenseCommand = /* @__PURE__ */ __name(async (output, context) => {
925
- if (output.statusCode >= 300) {
926
- return de_CommandError(output, context);
927
- }
928
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
929
- let contents = {};
930
- contents = de_AnalyzeExpenseResponse(data, context);
931
- const response = {
932
- $metadata: deserializeMetadata(output),
933
- ...contents
934
- };
935
- return response;
936
- }, "de_AnalyzeExpenseCommand");
937
- var de_AnalyzeIDCommand = /* @__PURE__ */ __name(async (output, context) => {
938
- if (output.statusCode >= 300) {
939
- return de_CommandError(output, context);
940
- }
941
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
942
- let contents = {};
943
- contents = de_AnalyzeIDResponse(data, context);
944
- const response = {
945
- $metadata: deserializeMetadata(output),
946
- ...contents
947
- };
948
- return response;
949
- }, "de_AnalyzeIDCommand");
950
- var de_CreateAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
951
- if (output.statusCode >= 300) {
952
- return de_CommandError(output, context);
953
- }
954
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
955
- let contents = {};
956
- contents = (0, import_smithy_client._json)(data);
957
- const response = {
958
- $metadata: deserializeMetadata(output),
959
- ...contents
960
- };
961
- return response;
962
- }, "de_CreateAdapterCommand");
963
- var de_CreateAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
964
- if (output.statusCode >= 300) {
965
- return de_CommandError(output, context);
966
- }
967
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
968
- let contents = {};
969
- contents = (0, import_smithy_client._json)(data);
970
- const response = {
971
- $metadata: deserializeMetadata(output),
972
- ...contents
973
- };
974
- return response;
975
- }, "de_CreateAdapterVersionCommand");
976
- var de_DeleteAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
977
- if (output.statusCode >= 300) {
978
- return de_CommandError(output, context);
979
- }
980
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
981
- let contents = {};
982
- contents = (0, import_smithy_client._json)(data);
983
- const response = {
984
- $metadata: deserializeMetadata(output),
985
- ...contents
986
- };
987
- return response;
988
- }, "de_DeleteAdapterCommand");
989
- var de_DeleteAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
990
- if (output.statusCode >= 300) {
991
- return de_CommandError(output, context);
992
- }
993
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
994
- let contents = {};
995
- contents = (0, import_smithy_client._json)(data);
996
- const response = {
997
- $metadata: deserializeMetadata(output),
998
- ...contents
999
- };
1000
- return response;
1001
- }, "de_DeleteAdapterVersionCommand");
1002
- var de_DetectDocumentTextCommand = /* @__PURE__ */ __name(async (output, context) => {
1003
- if (output.statusCode >= 300) {
1004
- return de_CommandError(output, context);
1005
- }
1006
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1007
- let contents = {};
1008
- contents = de_DetectDocumentTextResponse(data, context);
1009
- const response = {
1010
- $metadata: deserializeMetadata(output),
1011
- ...contents
1012
- };
1013
- return response;
1014
- }, "de_DetectDocumentTextCommand");
1015
- var de_GetAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
1016
- if (output.statusCode >= 300) {
1017
- return de_CommandError(output, context);
1018
- }
1019
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1020
- let contents = {};
1021
- contents = de_GetAdapterResponse(data, context);
1022
- const response = {
1023
- $metadata: deserializeMetadata(output),
1024
- ...contents
1025
- };
1026
- return response;
1027
- }, "de_GetAdapterCommand");
1028
- var de_GetAdapterVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
1029
- if (output.statusCode >= 300) {
1030
- return de_CommandError(output, context);
1031
- }
1032
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1033
- let contents = {};
1034
- contents = de_GetAdapterVersionResponse(data, context);
1035
- const response = {
1036
- $metadata: deserializeMetadata(output),
1037
- ...contents
1038
- };
1039
- return response;
1040
- }, "de_GetAdapterVersionCommand");
1041
- var de_GetDocumentAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1042
- if (output.statusCode >= 300) {
1043
- return de_CommandError(output, context);
1044
- }
1045
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1046
- let contents = {};
1047
- contents = de_GetDocumentAnalysisResponse(data, context);
1048
- const response = {
1049
- $metadata: deserializeMetadata(output),
1050
- ...contents
1051
- };
1052
- return response;
1053
- }, "de_GetDocumentAnalysisCommand");
1054
- var de_GetDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (output, context) => {
1055
- if (output.statusCode >= 300) {
1056
- return de_CommandError(output, context);
1057
- }
1058
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1059
- let contents = {};
1060
- contents = de_GetDocumentTextDetectionResponse(data, context);
1061
- const response = {
1062
- $metadata: deserializeMetadata(output),
1063
- ...contents
1064
- };
1065
- return response;
1066
- }, "de_GetDocumentTextDetectionCommand");
1067
- var de_GetExpenseAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1068
- if (output.statusCode >= 300) {
1069
- return de_CommandError(output, context);
1070
- }
1071
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1072
- let contents = {};
1073
- contents = de_GetExpenseAnalysisResponse(data, context);
1074
- const response = {
1075
- $metadata: deserializeMetadata(output),
1076
- ...contents
1077
- };
1078
- return response;
1079
- }, "de_GetExpenseAnalysisCommand");
1080
- var de_GetLendingAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1081
- if (output.statusCode >= 300) {
1082
- return de_CommandError(output, context);
1083
- }
1084
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1085
- let contents = {};
1086
- contents = de_GetLendingAnalysisResponse(data, context);
1087
- const response = {
1088
- $metadata: deserializeMetadata(output),
1089
- ...contents
1090
- };
1091
- return response;
1092
- }, "de_GetLendingAnalysisCommand");
1093
- var de_GetLendingAnalysisSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {
1094
- if (output.statusCode >= 300) {
1095
- return de_CommandError(output, context);
1096
- }
1097
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1098
- let contents = {};
1099
- contents = (0, import_smithy_client._json)(data);
1100
- const response = {
1101
- $metadata: deserializeMetadata(output),
1102
- ...contents
1103
- };
1104
- return response;
1105
- }, "de_GetLendingAnalysisSummaryCommand");
1106
- var de_ListAdaptersCommand = /* @__PURE__ */ __name(async (output, context) => {
1107
- if (output.statusCode >= 300) {
1108
- return de_CommandError(output, context);
1109
- }
1110
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1111
- let contents = {};
1112
- contents = de_ListAdaptersResponse(data, context);
1113
- const response = {
1114
- $metadata: deserializeMetadata(output),
1115
- ...contents
1116
- };
1117
- return response;
1118
- }, "de_ListAdaptersCommand");
1119
- var de_ListAdapterVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
1120
- if (output.statusCode >= 300) {
1121
- return de_CommandError(output, context);
1122
- }
1123
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1124
- let contents = {};
1125
- contents = de_ListAdapterVersionsResponse(data, context);
1126
- const response = {
1127
- $metadata: deserializeMetadata(output),
1128
- ...contents
1129
- };
1130
- return response;
1131
- }, "de_ListAdapterVersionsCommand");
1132
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1133
- if (output.statusCode >= 300) {
1134
- return de_CommandError(output, context);
1135
- }
1136
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1137
- let contents = {};
1138
- contents = (0, import_smithy_client._json)(data);
1139
- const response = {
1140
- $metadata: deserializeMetadata(output),
1141
- ...contents
1142
- };
1143
- return response;
1144
- }, "de_ListTagsForResourceCommand");
1145
- var de_StartDocumentAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1146
- if (output.statusCode >= 300) {
1147
- return de_CommandError(output, context);
1148
- }
1149
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1150
- let contents = {};
1151
- contents = (0, import_smithy_client._json)(data);
1152
- const response = {
1153
- $metadata: deserializeMetadata(output),
1154
- ...contents
1155
- };
1156
- return response;
1157
- }, "de_StartDocumentAnalysisCommand");
1158
- var de_StartDocumentTextDetectionCommand = /* @__PURE__ */ __name(async (output, context) => {
1159
- if (output.statusCode >= 300) {
1160
- return de_CommandError(output, context);
1161
- }
1162
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1163
- let contents = {};
1164
- contents = (0, import_smithy_client._json)(data);
1165
- const response = {
1166
- $metadata: deserializeMetadata(output),
1167
- ...contents
1168
- };
1169
- return response;
1170
- }, "de_StartDocumentTextDetectionCommand");
1171
- var de_StartExpenseAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1172
- if (output.statusCode >= 300) {
1173
- return de_CommandError(output, context);
1174
- }
1175
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1176
- let contents = {};
1177
- contents = (0, import_smithy_client._json)(data);
1178
- const response = {
1179
- $metadata: deserializeMetadata(output),
1180
- ...contents
1181
- };
1182
- return response;
1183
- }, "de_StartExpenseAnalysisCommand");
1184
- var de_StartLendingAnalysisCommand = /* @__PURE__ */ __name(async (output, context) => {
1185
- if (output.statusCode >= 300) {
1186
- return de_CommandError(output, context);
1187
- }
1188
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1189
- let contents = {};
1190
- contents = (0, import_smithy_client._json)(data);
1191
- const response = {
1192
- $metadata: deserializeMetadata(output),
1193
- ...contents
1194
- };
1195
- return response;
1196
- }, "de_StartLendingAnalysisCommand");
1197
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1198
- if (output.statusCode >= 300) {
1199
- return de_CommandError(output, context);
1200
- }
1201
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1202
- let contents = {};
1203
- contents = (0, import_smithy_client._json)(data);
1204
- const response = {
1205
- $metadata: deserializeMetadata(output),
1206
- ...contents
1207
- };
1208
- return response;
1209
- }, "de_TagResourceCommand");
1210
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1211
- if (output.statusCode >= 300) {
1212
- return de_CommandError(output, context);
1213
- }
1214
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1215
- let contents = {};
1216
- contents = (0, import_smithy_client._json)(data);
1217
- const response = {
1218
- $metadata: deserializeMetadata(output),
1219
- ...contents
1220
- };
1221
- return response;
1222
- }, "de_UntagResourceCommand");
1223
- var de_UpdateAdapterCommand = /* @__PURE__ */ __name(async (output, context) => {
1224
- if (output.statusCode >= 300) {
1225
- return de_CommandError(output, context);
1226
- }
1227
- const data = await (0, import_core2.parseJsonBody)(output.body, context);
1228
- let contents = {};
1229
- contents = de_UpdateAdapterResponse(data, context);
1230
- const response = {
1231
- $metadata: deserializeMetadata(output),
1232
- ...contents
1233
- };
1234
- return response;
1235
- }, "de_UpdateAdapterCommand");
1236
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1237
- const parsedOutput = {
1238
- ...output,
1239
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1240
- };
1241
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1242
- switch (errorCode) {
1243
- case "AccessDeniedException":
1244
- case "com.amazonaws.textract#AccessDeniedException":
1245
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1246
- case "BadDocumentException":
1247
- case "com.amazonaws.textract#BadDocumentException":
1248
- throw await de_BadDocumentExceptionRes(parsedOutput, context);
1249
- case "DocumentTooLargeException":
1250
- case "com.amazonaws.textract#DocumentTooLargeException":
1251
- throw await de_DocumentTooLargeExceptionRes(parsedOutput, context);
1252
- case "HumanLoopQuotaExceededException":
1253
- case "com.amazonaws.textract#HumanLoopQuotaExceededException":
1254
- throw await de_HumanLoopQuotaExceededExceptionRes(parsedOutput, context);
1255
- case "InternalServerError":
1256
- case "com.amazonaws.textract#InternalServerError":
1257
- throw await de_InternalServerErrorRes(parsedOutput, context);
1258
- case "InvalidParameterException":
1259
- case "com.amazonaws.textract#InvalidParameterException":
1260
- throw await de_InvalidParameterExceptionRes(parsedOutput, context);
1261
- case "InvalidS3ObjectException":
1262
- case "com.amazonaws.textract#InvalidS3ObjectException":
1263
- throw await de_InvalidS3ObjectExceptionRes(parsedOutput, context);
1264
- case "ProvisionedThroughputExceededException":
1265
- case "com.amazonaws.textract#ProvisionedThroughputExceededException":
1266
- throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
1267
- case "ThrottlingException":
1268
- case "com.amazonaws.textract#ThrottlingException":
1269
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1270
- case "UnsupportedDocumentException":
1271
- case "com.amazonaws.textract#UnsupportedDocumentException":
1272
- throw await de_UnsupportedDocumentExceptionRes(parsedOutput, context);
1273
- case "ConflictException":
1274
- case "com.amazonaws.textract#ConflictException":
1275
- throw await de_ConflictExceptionRes(parsedOutput, context);
1276
- case "IdempotentParameterMismatchException":
1277
- case "com.amazonaws.textract#IdempotentParameterMismatchException":
1278
- throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
1279
- case "LimitExceededException":
1280
- case "com.amazonaws.textract#LimitExceededException":
1281
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1282
- case "ServiceQuotaExceededException":
1283
- case "com.amazonaws.textract#ServiceQuotaExceededException":
1284
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1285
- case "ValidationException":
1286
- case "com.amazonaws.textract#ValidationException":
1287
- throw await de_ValidationExceptionRes(parsedOutput, context);
1288
- case "InvalidKMSKeyException":
1289
- case "com.amazonaws.textract#InvalidKMSKeyException":
1290
- throw await de_InvalidKMSKeyExceptionRes(parsedOutput, context);
1291
- case "ResourceNotFoundException":
1292
- case "com.amazonaws.textract#ResourceNotFoundException":
1293
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1294
- case "InvalidJobIdException":
1295
- case "com.amazonaws.textract#InvalidJobIdException":
1296
- throw await de_InvalidJobIdExceptionRes(parsedOutput, context);
1297
- default:
1298
- const parsedBody = parsedOutput.body;
1299
- return throwDefaultError({
1300
- output,
1301
- parsedBody,
1302
- errorCode
1303
- });
1304
- }
1305
- }, "de_CommandError");
1306
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1307
- const body = parsedOutput.body;
1308
- const deserialized = (0, import_smithy_client._json)(body);
1309
- const exception = new AccessDeniedException({
1310
- $metadata: deserializeMetadata(parsedOutput),
1311
- ...deserialized
1312
- });
1313
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1314
- }, "de_AccessDeniedExceptionRes");
1315
- var de_BadDocumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1316
- const body = parsedOutput.body;
1317
- const deserialized = (0, import_smithy_client._json)(body);
1318
- const exception = new BadDocumentException({
1319
- $metadata: deserializeMetadata(parsedOutput),
1320
- ...deserialized
1321
- });
1322
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1323
- }, "de_BadDocumentExceptionRes");
1324
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1325
- const body = parsedOutput.body;
1326
- const deserialized = (0, import_smithy_client._json)(body);
1327
- const exception = new ConflictException({
1328
- $metadata: deserializeMetadata(parsedOutput),
1329
- ...deserialized
1330
- });
1331
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1332
- }, "de_ConflictExceptionRes");
1333
- var de_DocumentTooLargeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1334
- const body = parsedOutput.body;
1335
- const deserialized = (0, import_smithy_client._json)(body);
1336
- const exception = new DocumentTooLargeException({
1337
- $metadata: deserializeMetadata(parsedOutput),
1338
- ...deserialized
1339
- });
1340
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1341
- }, "de_DocumentTooLargeExceptionRes");
1342
- var de_HumanLoopQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1343
- const body = parsedOutput.body;
1344
- const deserialized = (0, import_smithy_client._json)(body);
1345
- const exception = new HumanLoopQuotaExceededException({
1346
- $metadata: deserializeMetadata(parsedOutput),
1347
- ...deserialized
1348
- });
1349
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1350
- }, "de_HumanLoopQuotaExceededExceptionRes");
1351
- var de_IdempotentParameterMismatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1352
- const body = parsedOutput.body;
1353
- const deserialized = (0, import_smithy_client._json)(body);
1354
- const exception = new IdempotentParameterMismatchException({
1355
- $metadata: deserializeMetadata(parsedOutput),
1356
- ...deserialized
1357
- });
1358
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1359
- }, "de_IdempotentParameterMismatchExceptionRes");
1360
- var de_InternalServerErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1361
- const body = parsedOutput.body;
1362
- const deserialized = (0, import_smithy_client._json)(body);
1363
- const exception = new InternalServerError({
1364
- $metadata: deserializeMetadata(parsedOutput),
1365
- ...deserialized
1366
- });
1367
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1368
- }, "de_InternalServerErrorRes");
1369
- var de_InvalidJobIdExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1370
- const body = parsedOutput.body;
1371
- const deserialized = (0, import_smithy_client._json)(body);
1372
- const exception = new InvalidJobIdException({
1373
- $metadata: deserializeMetadata(parsedOutput),
1374
- ...deserialized
1375
- });
1376
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1377
- }, "de_InvalidJobIdExceptionRes");
1378
- var de_InvalidKMSKeyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1379
- const body = parsedOutput.body;
1380
- const deserialized = (0, import_smithy_client._json)(body);
1381
- const exception = new InvalidKMSKeyException({
1382
- $metadata: deserializeMetadata(parsedOutput),
1383
- ...deserialized
1384
- });
1385
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1386
- }, "de_InvalidKMSKeyExceptionRes");
1387
- var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1388
- const body = parsedOutput.body;
1389
- const deserialized = (0, import_smithy_client._json)(body);
1390
- const exception = new InvalidParameterException({
1391
- $metadata: deserializeMetadata(parsedOutput),
1392
- ...deserialized
1393
- });
1394
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1395
- }, "de_InvalidParameterExceptionRes");
1396
- var de_InvalidS3ObjectExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1397
- const body = parsedOutput.body;
1398
- const deserialized = (0, import_smithy_client._json)(body);
1399
- const exception = new InvalidS3ObjectException({
1400
- $metadata: deserializeMetadata(parsedOutput),
1401
- ...deserialized
1402
- });
1403
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1404
- }, "de_InvalidS3ObjectExceptionRes");
1405
- var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1406
- const body = parsedOutput.body;
1407
- const deserialized = (0, import_smithy_client._json)(body);
1408
- const exception = new LimitExceededException({
1409
- $metadata: deserializeMetadata(parsedOutput),
1410
- ...deserialized
1411
- });
1412
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1413
- }, "de_LimitExceededExceptionRes");
1414
- var de_ProvisionedThroughputExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1415
- const body = parsedOutput.body;
1416
- const deserialized = (0, import_smithy_client._json)(body);
1417
- const exception = new ProvisionedThroughputExceededException({
1418
- $metadata: deserializeMetadata(parsedOutput),
1419
- ...deserialized
1420
- });
1421
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1422
- }, "de_ProvisionedThroughputExceededExceptionRes");
1423
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1424
- const body = parsedOutput.body;
1425
- const deserialized = (0, import_smithy_client._json)(body);
1426
- const exception = new ResourceNotFoundException({
1427
- $metadata: deserializeMetadata(parsedOutput),
1428
- ...deserialized
1429
- });
1430
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1431
- }, "de_ResourceNotFoundExceptionRes");
1432
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1433
- const body = parsedOutput.body;
1434
- const deserialized = (0, import_smithy_client._json)(body);
1435
- const exception = new ServiceQuotaExceededException({
1436
- $metadata: deserializeMetadata(parsedOutput),
1437
- ...deserialized
1438
- });
1439
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1440
- }, "de_ServiceQuotaExceededExceptionRes");
1441
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1442
- const body = parsedOutput.body;
1443
- const deserialized = (0, import_smithy_client._json)(body);
1444
- const exception = new ThrottlingException({
1445
- $metadata: deserializeMetadata(parsedOutput),
1446
- ...deserialized
1447
- });
1448
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1449
- }, "de_ThrottlingExceptionRes");
1450
- var de_UnsupportedDocumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1451
- const body = parsedOutput.body;
1452
- const deserialized = (0, import_smithy_client._json)(body);
1453
- const exception = new UnsupportedDocumentException({
1454
- $metadata: deserializeMetadata(parsedOutput),
1455
- ...deserialized
1456
- });
1457
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1458
- }, "de_UnsupportedDocumentExceptionRes");
1459
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1460
- const body = parsedOutput.body;
1461
- const deserialized = (0, import_smithy_client._json)(body);
1462
- const exception = new ValidationException({
1463
- $metadata: deserializeMetadata(parsedOutput),
1464
- ...deserialized
1465
- });
1466
- return (0, import_smithy_client.decorateServiceException)(exception, body);
1467
- }, "de_ValidationExceptionRes");
1468
- var se_AnalyzeDocumentRequest = /* @__PURE__ */ __name((input, context) => {
1469
- return (0, import_smithy_client.take)(input, {
1470
- AdaptersConfig: import_smithy_client._json,
1471
- Document: /* @__PURE__ */ __name((_) => se_Document(_, context), "Document"),
1472
- FeatureTypes: import_smithy_client._json,
1473
- HumanLoopConfig: import_smithy_client._json,
1474
- QueriesConfig: import_smithy_client._json
1475
- });
1476
- }, "se_AnalyzeDocumentRequest");
1477
- var se_AnalyzeExpenseRequest = /* @__PURE__ */ __name((input, context) => {
1478
- return (0, import_smithy_client.take)(input, {
1479
- Document: /* @__PURE__ */ __name((_) => se_Document(_, context), "Document")
1480
- });
1481
- }, "se_AnalyzeExpenseRequest");
1482
- var se_AnalyzeIDRequest = /* @__PURE__ */ __name((input, context) => {
1483
- return (0, import_smithy_client.take)(input, {
1484
- DocumentPages: /* @__PURE__ */ __name((_) => se_DocumentPages(_, context), "DocumentPages")
1485
- });
1486
- }, "se_AnalyzeIDRequest");
1487
- var se_CreateAdapterRequest = /* @__PURE__ */ __name((input, context) => {
1488
- return (0, import_smithy_client.take)(input, {
1489
- AdapterName: [],
1490
- AutoUpdate: [],
1491
- ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
1492
- Description: [],
1493
- FeatureTypes: import_smithy_client._json,
1494
- Tags: import_smithy_client._json
1495
- });
1496
- }, "se_CreateAdapterRequest");
1497
- var se_CreateAdapterVersionRequest = /* @__PURE__ */ __name((input, context) => {
1498
- return (0, import_smithy_client.take)(input, {
1499
- AdapterId: [],
1500
- ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
1501
- DatasetConfig: import_smithy_client._json,
1502
- KMSKeyId: [],
1503
- OutputConfig: import_smithy_client._json,
1504
- Tags: import_smithy_client._json
1505
- });
1506
- }, "se_CreateAdapterVersionRequest");
1507
- var se_DetectDocumentTextRequest = /* @__PURE__ */ __name((input, context) => {
1508
- return (0, import_smithy_client.take)(input, {
1509
- Document: /* @__PURE__ */ __name((_) => se_Document(_, context), "Document")
1510
- });
1511
- }, "se_DetectDocumentTextRequest");
1512
- var se_Document = /* @__PURE__ */ __name((input, context) => {
1513
- return (0, import_smithy_client.take)(input, {
1514
- Bytes: context.base64Encoder,
1515
- S3Object: import_smithy_client._json
1516
- });
1517
- }, "se_Document");
1518
- var se_DocumentPages = /* @__PURE__ */ __name((input, context) => {
1519
- return input.filter((e) => e != null).map((entry) => {
1520
- return se_Document(entry, context);
1521
- });
1522
- }, "se_DocumentPages");
1523
- var se_ListAdaptersRequest = /* @__PURE__ */ __name((input, context) => {
1524
- return (0, import_smithy_client.take)(input, {
1525
- AfterCreationTime: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "AfterCreationTime"),
1526
- BeforeCreationTime: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "BeforeCreationTime"),
1527
- MaxResults: [],
1528
- NextToken: []
1529
- });
1530
- }, "se_ListAdaptersRequest");
1531
- var se_ListAdapterVersionsRequest = /* @__PURE__ */ __name((input, context) => {
1532
- return (0, import_smithy_client.take)(input, {
1533
- AdapterId: [],
1534
- AfterCreationTime: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "AfterCreationTime"),
1535
- BeforeCreationTime: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "BeforeCreationTime"),
1536
- MaxResults: [],
1537
- NextToken: []
1538
- });
1539
- }, "se_ListAdapterVersionsRequest");
1540
- var de_AdapterList = /* @__PURE__ */ __name((output, context) => {
1541
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1542
- return de_AdapterOverview(entry, context);
1543
- });
1544
- return retVal;
1545
- }, "de_AdapterList");
1546
- var de_AdapterOverview = /* @__PURE__ */ __name((output, context) => {
1547
- return (0, import_smithy_client.take)(output, {
1548
- AdapterId: import_smithy_client.expectString,
1549
- AdapterName: import_smithy_client.expectString,
1550
- CreationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
1551
- FeatureTypes: import_smithy_client._json
1552
- });
1553
- }, "de_AdapterOverview");
1554
- var de_AdapterVersionEvaluationMetric = /* @__PURE__ */ __name((output, context) => {
1555
- return (0, import_smithy_client.take)(output, {
1556
- AdapterVersion: /* @__PURE__ */ __name((_) => de_EvaluationMetric(_, context), "AdapterVersion"),
1557
- Baseline: /* @__PURE__ */ __name((_) => de_EvaluationMetric(_, context), "Baseline"),
1558
- FeatureType: import_smithy_client.expectString
1559
- });
1560
- }, "de_AdapterVersionEvaluationMetric");
1561
- var de_AdapterVersionEvaluationMetrics = /* @__PURE__ */ __name((output, context) => {
1562
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1563
- return de_AdapterVersionEvaluationMetric(entry, context);
1564
- });
1565
- return retVal;
1566
- }, "de_AdapterVersionEvaluationMetrics");
1567
- var de_AdapterVersionList = /* @__PURE__ */ __name((output, context) => {
1568
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1569
- return de_AdapterVersionOverview(entry, context);
1570
- });
1571
- return retVal;
1572
- }, "de_AdapterVersionList");
1573
- var de_AdapterVersionOverview = /* @__PURE__ */ __name((output, context) => {
1574
- return (0, import_smithy_client.take)(output, {
1575
- AdapterId: import_smithy_client.expectString,
1576
- AdapterVersion: import_smithy_client.expectString,
1577
- CreationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
1578
- FeatureTypes: import_smithy_client._json,
1579
- Status: import_smithy_client.expectString,
1580
- StatusMessage: import_smithy_client.expectString
1581
- });
1582
- }, "de_AdapterVersionOverview");
1583
- var de_AnalyzeDocumentResponse = /* @__PURE__ */ __name((output, context) => {
1584
- return (0, import_smithy_client.take)(output, {
1585
- AnalyzeDocumentModelVersion: import_smithy_client.expectString,
1586
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1587
- DocumentMetadata: import_smithy_client._json,
1588
- HumanLoopActivationOutput: /* @__PURE__ */ __name((_) => de_HumanLoopActivationOutput(_, context), "HumanLoopActivationOutput")
1589
- });
1590
- }, "de_AnalyzeDocumentResponse");
1591
- var de_AnalyzeExpenseResponse = /* @__PURE__ */ __name((output, context) => {
1592
- return (0, import_smithy_client.take)(output, {
1593
- DocumentMetadata: import_smithy_client._json,
1594
- ExpenseDocuments: /* @__PURE__ */ __name((_) => de_ExpenseDocumentList(_, context), "ExpenseDocuments")
1595
- });
1596
- }, "de_AnalyzeExpenseResponse");
1597
- var de_AnalyzeIDDetections = /* @__PURE__ */ __name((output, context) => {
1598
- return (0, import_smithy_client.take)(output, {
1599
- Confidence: import_smithy_client.limitedParseFloat32,
1600
- NormalizedValue: import_smithy_client._json,
1601
- Text: import_smithy_client.expectString
1602
- });
1603
- }, "de_AnalyzeIDDetections");
1604
- var de_AnalyzeIDResponse = /* @__PURE__ */ __name((output, context) => {
1605
- return (0, import_smithy_client.take)(output, {
1606
- AnalyzeIDModelVersion: import_smithy_client.expectString,
1607
- DocumentMetadata: import_smithy_client._json,
1608
- IdentityDocuments: /* @__PURE__ */ __name((_) => de_IdentityDocumentList(_, context), "IdentityDocuments")
1609
- });
1610
- }, "de_AnalyzeIDResponse");
1611
- var de_Block = /* @__PURE__ */ __name((output, context) => {
1612
- return (0, import_smithy_client.take)(output, {
1613
- BlockType: import_smithy_client.expectString,
1614
- ColumnIndex: import_smithy_client.expectInt32,
1615
- ColumnSpan: import_smithy_client.expectInt32,
1616
- Confidence: import_smithy_client.limitedParseFloat32,
1617
- EntityTypes: import_smithy_client._json,
1618
- Geometry: /* @__PURE__ */ __name((_) => de_Geometry(_, context), "Geometry"),
1619
- Id: import_smithy_client.expectString,
1620
- Page: import_smithy_client.expectInt32,
1621
- Query: import_smithy_client._json,
1622
- Relationships: import_smithy_client._json,
1623
- RowIndex: import_smithy_client.expectInt32,
1624
- RowSpan: import_smithy_client.expectInt32,
1625
- SelectionStatus: import_smithy_client.expectString,
1626
- Text: import_smithy_client.expectString,
1627
- TextType: import_smithy_client.expectString
1628
- });
1629
- }, "de_Block");
1630
- var de_BlockList = /* @__PURE__ */ __name((output, context) => {
1631
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1632
- return de_Block(entry, context);
1633
- });
1634
- return retVal;
1635
- }, "de_BlockList");
1636
- var de_BoundingBox = /* @__PURE__ */ __name((output, context) => {
1637
- return (0, import_smithy_client.take)(output, {
1638
- Height: import_smithy_client.limitedParseFloat32,
1639
- Left: import_smithy_client.limitedParseFloat32,
1640
- Top: import_smithy_client.limitedParseFloat32,
1641
- Width: import_smithy_client.limitedParseFloat32
1642
- });
1643
- }, "de_BoundingBox");
1644
- var de_DetectDocumentTextResponse = /* @__PURE__ */ __name((output, context) => {
1645
- return (0, import_smithy_client.take)(output, {
1646
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1647
- DetectDocumentTextModelVersion: import_smithy_client.expectString,
1648
- DocumentMetadata: import_smithy_client._json
1649
- });
1650
- }, "de_DetectDocumentTextResponse");
1651
- var de_EvaluationMetric = /* @__PURE__ */ __name((output, context) => {
1652
- return (0, import_smithy_client.take)(output, {
1653
- F1Score: import_smithy_client.limitedParseFloat32,
1654
- Precision: import_smithy_client.limitedParseFloat32,
1655
- Recall: import_smithy_client.limitedParseFloat32
1656
- });
1657
- }, "de_EvaluationMetric");
1658
- var de_ExpenseCurrency = /* @__PURE__ */ __name((output, context) => {
1659
- return (0, import_smithy_client.take)(output, {
1660
- Code: import_smithy_client.expectString,
1661
- Confidence: import_smithy_client.limitedParseFloat32
1662
- });
1663
- }, "de_ExpenseCurrency");
1664
- var de_ExpenseDetection = /* @__PURE__ */ __name((output, context) => {
1665
- return (0, import_smithy_client.take)(output, {
1666
- Confidence: import_smithy_client.limitedParseFloat32,
1667
- Geometry: /* @__PURE__ */ __name((_) => de_Geometry(_, context), "Geometry"),
1668
- Text: import_smithy_client.expectString
1669
- });
1670
- }, "de_ExpenseDetection");
1671
- var de_ExpenseDocument = /* @__PURE__ */ __name((output, context) => {
1672
- return (0, import_smithy_client.take)(output, {
1673
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1674
- ExpenseIndex: import_smithy_client.expectInt32,
1675
- LineItemGroups: /* @__PURE__ */ __name((_) => de_LineItemGroupList(_, context), "LineItemGroups"),
1676
- SummaryFields: /* @__PURE__ */ __name((_) => de_ExpenseFieldList(_, context), "SummaryFields")
1677
- });
1678
- }, "de_ExpenseDocument");
1679
- var de_ExpenseDocumentList = /* @__PURE__ */ __name((output, context) => {
1680
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1681
- return de_ExpenseDocument(entry, context);
1682
- });
1683
- return retVal;
1684
- }, "de_ExpenseDocumentList");
1685
- var de_ExpenseField = /* @__PURE__ */ __name((output, context) => {
1686
- return (0, import_smithy_client.take)(output, {
1687
- Currency: /* @__PURE__ */ __name((_) => de_ExpenseCurrency(_, context), "Currency"),
1688
- GroupProperties: import_smithy_client._json,
1689
- LabelDetection: /* @__PURE__ */ __name((_) => de_ExpenseDetection(_, context), "LabelDetection"),
1690
- PageNumber: import_smithy_client.expectInt32,
1691
- Type: /* @__PURE__ */ __name((_) => de_ExpenseType(_, context), "Type"),
1692
- ValueDetection: /* @__PURE__ */ __name((_) => de_ExpenseDetection(_, context), "ValueDetection")
1693
- });
1694
- }, "de_ExpenseField");
1695
- var de_ExpenseFieldList = /* @__PURE__ */ __name((output, context) => {
1696
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1697
- return de_ExpenseField(entry, context);
1698
- });
1699
- return retVal;
1700
- }, "de_ExpenseFieldList");
1701
- var de_ExpenseType = /* @__PURE__ */ __name((output, context) => {
1702
- return (0, import_smithy_client.take)(output, {
1703
- Confidence: import_smithy_client.limitedParseFloat32,
1704
- Text: import_smithy_client.expectString
1705
- });
1706
- }, "de_ExpenseType");
1707
- var de_Extraction = /* @__PURE__ */ __name((output, context) => {
1708
- return (0, import_smithy_client.take)(output, {
1709
- ExpenseDocument: /* @__PURE__ */ __name((_) => de_ExpenseDocument(_, context), "ExpenseDocument"),
1710
- IdentityDocument: /* @__PURE__ */ __name((_) => de_IdentityDocument(_, context), "IdentityDocument"),
1711
- LendingDocument: /* @__PURE__ */ __name((_) => de_LendingDocument(_, context), "LendingDocument")
1712
- });
1713
- }, "de_Extraction");
1714
- var de_ExtractionList = /* @__PURE__ */ __name((output, context) => {
1715
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1716
- return de_Extraction(entry, context);
1717
- });
1718
- return retVal;
1719
- }, "de_ExtractionList");
1720
- var de_Geometry = /* @__PURE__ */ __name((output, context) => {
1721
- return (0, import_smithy_client.take)(output, {
1722
- BoundingBox: /* @__PURE__ */ __name((_) => de_BoundingBox(_, context), "BoundingBox"),
1723
- Polygon: /* @__PURE__ */ __name((_) => de_Polygon(_, context), "Polygon"),
1724
- RotationAngle: import_smithy_client.limitedParseFloat32
1725
- });
1726
- }, "de_Geometry");
1727
- var de_GetAdapterResponse = /* @__PURE__ */ __name((output, context) => {
1728
- return (0, import_smithy_client.take)(output, {
1729
- AdapterId: import_smithy_client.expectString,
1730
- AdapterName: import_smithy_client.expectString,
1731
- AutoUpdate: import_smithy_client.expectString,
1732
- CreationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
1733
- Description: import_smithy_client.expectString,
1734
- FeatureTypes: import_smithy_client._json,
1735
- Tags: import_smithy_client._json
1736
- });
1737
- }, "de_GetAdapterResponse");
1738
- var de_GetAdapterVersionResponse = /* @__PURE__ */ __name((output, context) => {
1739
- return (0, import_smithy_client.take)(output, {
1740
- AdapterId: import_smithy_client.expectString,
1741
- AdapterVersion: import_smithy_client.expectString,
1742
- CreationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
1743
- DatasetConfig: import_smithy_client._json,
1744
- EvaluationMetrics: /* @__PURE__ */ __name((_) => de_AdapterVersionEvaluationMetrics(_, context), "EvaluationMetrics"),
1745
- FeatureTypes: import_smithy_client._json,
1746
- KMSKeyId: import_smithy_client.expectString,
1747
- OutputConfig: import_smithy_client._json,
1748
- Status: import_smithy_client.expectString,
1749
- StatusMessage: import_smithy_client.expectString,
1750
- Tags: import_smithy_client._json
1751
- });
1752
- }, "de_GetAdapterVersionResponse");
1753
- var de_GetDocumentAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
1754
- return (0, import_smithy_client.take)(output, {
1755
- AnalyzeDocumentModelVersion: import_smithy_client.expectString,
1756
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1757
- DocumentMetadata: import_smithy_client._json,
1758
- JobStatus: import_smithy_client.expectString,
1759
- NextToken: import_smithy_client.expectString,
1760
- StatusMessage: import_smithy_client.expectString,
1761
- Warnings: import_smithy_client._json
1762
- });
1763
- }, "de_GetDocumentAnalysisResponse");
1764
- var de_GetDocumentTextDetectionResponse = /* @__PURE__ */ __name((output, context) => {
1765
- return (0, import_smithy_client.take)(output, {
1766
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1767
- DetectDocumentTextModelVersion: import_smithy_client.expectString,
1768
- DocumentMetadata: import_smithy_client._json,
1769
- JobStatus: import_smithy_client.expectString,
1770
- NextToken: import_smithy_client.expectString,
1771
- StatusMessage: import_smithy_client.expectString,
1772
- Warnings: import_smithy_client._json
1773
- });
1774
- }, "de_GetDocumentTextDetectionResponse");
1775
- var de_GetExpenseAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
1776
- return (0, import_smithy_client.take)(output, {
1777
- AnalyzeExpenseModelVersion: import_smithy_client.expectString,
1778
- DocumentMetadata: import_smithy_client._json,
1779
- ExpenseDocuments: /* @__PURE__ */ __name((_) => de_ExpenseDocumentList(_, context), "ExpenseDocuments"),
1780
- JobStatus: import_smithy_client.expectString,
1781
- NextToken: import_smithy_client.expectString,
1782
- StatusMessage: import_smithy_client.expectString,
1783
- Warnings: import_smithy_client._json
1784
- });
1785
- }, "de_GetExpenseAnalysisResponse");
1786
- var de_GetLendingAnalysisResponse = /* @__PURE__ */ __name((output, context) => {
1787
- return (0, import_smithy_client.take)(output, {
1788
- AnalyzeLendingModelVersion: import_smithy_client.expectString,
1789
- DocumentMetadata: import_smithy_client._json,
1790
- JobStatus: import_smithy_client.expectString,
1791
- NextToken: import_smithy_client.expectString,
1792
- Results: /* @__PURE__ */ __name((_) => de_LendingResultList(_, context), "Results"),
1793
- StatusMessage: import_smithy_client.expectString,
1794
- Warnings: import_smithy_client._json
1795
- });
1796
- }, "de_GetLendingAnalysisResponse");
1797
- var de_HumanLoopActivationOutput = /* @__PURE__ */ __name((output, context) => {
1798
- return (0, import_smithy_client.take)(output, {
1799
- HumanLoopActivationConditionsEvaluationResults: import_smithy_client.LazyJsonString.from,
1800
- HumanLoopActivationReasons: import_smithy_client._json,
1801
- HumanLoopArn: import_smithy_client.expectString
1802
- });
1803
- }, "de_HumanLoopActivationOutput");
1804
- var de_IdentityDocument = /* @__PURE__ */ __name((output, context) => {
1805
- return (0, import_smithy_client.take)(output, {
1806
- Blocks: /* @__PURE__ */ __name((_) => de_BlockList(_, context), "Blocks"),
1807
- DocumentIndex: import_smithy_client.expectInt32,
1808
- IdentityDocumentFields: /* @__PURE__ */ __name((_) => de_IdentityDocumentFieldList(_, context), "IdentityDocumentFields")
1809
- });
1810
- }, "de_IdentityDocument");
1811
- var de_IdentityDocumentField = /* @__PURE__ */ __name((output, context) => {
1812
- return (0, import_smithy_client.take)(output, {
1813
- Type: /* @__PURE__ */ __name((_) => de_AnalyzeIDDetections(_, context), "Type"),
1814
- ValueDetection: /* @__PURE__ */ __name((_) => de_AnalyzeIDDetections(_, context), "ValueDetection")
1815
- });
1816
- }, "de_IdentityDocumentField");
1817
- var de_IdentityDocumentFieldList = /* @__PURE__ */ __name((output, context) => {
1818
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1819
- return de_IdentityDocumentField(entry, context);
1820
- });
1821
- return retVal;
1822
- }, "de_IdentityDocumentFieldList");
1823
- var de_IdentityDocumentList = /* @__PURE__ */ __name((output, context) => {
1824
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1825
- return de_IdentityDocument(entry, context);
1826
- });
1827
- return retVal;
1828
- }, "de_IdentityDocumentList");
1829
- var de_LendingDetection = /* @__PURE__ */ __name((output, context) => {
1830
- return (0, import_smithy_client.take)(output, {
1831
- Confidence: import_smithy_client.limitedParseFloat32,
1832
- Geometry: /* @__PURE__ */ __name((_) => de_Geometry(_, context), "Geometry"),
1833
- SelectionStatus: import_smithy_client.expectString,
1834
- Text: import_smithy_client.expectString
1835
- });
1836
- }, "de_LendingDetection");
1837
- var de_LendingDetectionList = /* @__PURE__ */ __name((output, context) => {
1838
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1839
- return de_LendingDetection(entry, context);
1840
- });
1841
- return retVal;
1842
- }, "de_LendingDetectionList");
1843
- var de_LendingDocument = /* @__PURE__ */ __name((output, context) => {
1844
- return (0, import_smithy_client.take)(output, {
1845
- LendingFields: /* @__PURE__ */ __name((_) => de_LendingFieldList(_, context), "LendingFields"),
1846
- SignatureDetections: /* @__PURE__ */ __name((_) => de_SignatureDetectionList(_, context), "SignatureDetections")
1847
- });
1848
- }, "de_LendingDocument");
1849
- var de_LendingField = /* @__PURE__ */ __name((output, context) => {
1850
- return (0, import_smithy_client.take)(output, {
1851
- KeyDetection: /* @__PURE__ */ __name((_) => de_LendingDetection(_, context), "KeyDetection"),
1852
- Type: import_smithy_client.expectString,
1853
- ValueDetections: /* @__PURE__ */ __name((_) => de_LendingDetectionList(_, context), "ValueDetections")
1854
- });
1855
- }, "de_LendingField");
1856
- var de_LendingFieldList = /* @__PURE__ */ __name((output, context) => {
1857
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1858
- return de_LendingField(entry, context);
1859
- });
1860
- return retVal;
1861
- }, "de_LendingFieldList");
1862
- var de_LendingResult = /* @__PURE__ */ __name((output, context) => {
1863
- return (0, import_smithy_client.take)(output, {
1864
- Extractions: /* @__PURE__ */ __name((_) => de_ExtractionList(_, context), "Extractions"),
1865
- Page: import_smithy_client.expectInt32,
1866
- PageClassification: /* @__PURE__ */ __name((_) => de_PageClassification(_, context), "PageClassification")
1867
- });
1868
- }, "de_LendingResult");
1869
- var de_LendingResultList = /* @__PURE__ */ __name((output, context) => {
1870
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1871
- return de_LendingResult(entry, context);
1872
- });
1873
- return retVal;
1874
- }, "de_LendingResultList");
1875
- var de_LineItemFields = /* @__PURE__ */ __name((output, context) => {
1876
- return (0, import_smithy_client.take)(output, {
1877
- LineItemExpenseFields: /* @__PURE__ */ __name((_) => de_ExpenseFieldList(_, context), "LineItemExpenseFields")
1878
- });
1879
- }, "de_LineItemFields");
1880
- var de_LineItemGroup = /* @__PURE__ */ __name((output, context) => {
1881
- return (0, import_smithy_client.take)(output, {
1882
- LineItemGroupIndex: import_smithy_client.expectInt32,
1883
- LineItems: /* @__PURE__ */ __name((_) => de_LineItemList(_, context), "LineItems")
1884
- });
1885
- }, "de_LineItemGroup");
1886
- var de_LineItemGroupList = /* @__PURE__ */ __name((output, context) => {
1887
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1888
- return de_LineItemGroup(entry, context);
1889
- });
1890
- return retVal;
1891
- }, "de_LineItemGroupList");
1892
- var de_LineItemList = /* @__PURE__ */ __name((output, context) => {
1893
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1894
- return de_LineItemFields(entry, context);
1895
- });
1896
- return retVal;
1897
- }, "de_LineItemList");
1898
- var de_ListAdaptersResponse = /* @__PURE__ */ __name((output, context) => {
1899
- return (0, import_smithy_client.take)(output, {
1900
- Adapters: /* @__PURE__ */ __name((_) => de_AdapterList(_, context), "Adapters"),
1901
- NextToken: import_smithy_client.expectString
1902
- });
1903
- }, "de_ListAdaptersResponse");
1904
- var de_ListAdapterVersionsResponse = /* @__PURE__ */ __name((output, context) => {
1905
- return (0, import_smithy_client.take)(output, {
1906
- AdapterVersions: /* @__PURE__ */ __name((_) => de_AdapterVersionList(_, context), "AdapterVersions"),
1907
- NextToken: import_smithy_client.expectString
1908
- });
1909
- }, "de_ListAdapterVersionsResponse");
1910
- var de_PageClassification = /* @__PURE__ */ __name((output, context) => {
1911
- return (0, import_smithy_client.take)(output, {
1912
- PageNumber: /* @__PURE__ */ __name((_) => de_PredictionList(_, context), "PageNumber"),
1913
- PageType: /* @__PURE__ */ __name((_) => de_PredictionList(_, context), "PageType")
1914
- });
1915
- }, "de_PageClassification");
1916
- var de_Point = /* @__PURE__ */ __name((output, context) => {
1917
- return (0, import_smithy_client.take)(output, {
1918
- X: import_smithy_client.limitedParseFloat32,
1919
- Y: import_smithy_client.limitedParseFloat32
1920
- });
1921
- }, "de_Point");
1922
- var de_Polygon = /* @__PURE__ */ __name((output, context) => {
1923
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1924
- return de_Point(entry, context);
1925
- });
1926
- return retVal;
1927
- }, "de_Polygon");
1928
- var de_Prediction = /* @__PURE__ */ __name((output, context) => {
1929
- return (0, import_smithy_client.take)(output, {
1930
- Confidence: import_smithy_client.limitedParseFloat32,
1931
- Value: import_smithy_client.expectString
1932
- });
1933
- }, "de_Prediction");
1934
- var de_PredictionList = /* @__PURE__ */ __name((output, context) => {
1935
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1936
- return de_Prediction(entry, context);
1937
- });
1938
- return retVal;
1939
- }, "de_PredictionList");
1940
- var de_SignatureDetection = /* @__PURE__ */ __name((output, context) => {
1941
- return (0, import_smithy_client.take)(output, {
1942
- Confidence: import_smithy_client.limitedParseFloat32,
1943
- Geometry: /* @__PURE__ */ __name((_) => de_Geometry(_, context), "Geometry")
1944
- });
1945
- }, "de_SignatureDetection");
1946
- var de_SignatureDetectionList = /* @__PURE__ */ __name((output, context) => {
1947
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1948
- return de_SignatureDetection(entry, context);
1949
- });
1950
- return retVal;
1951
- }, "de_SignatureDetectionList");
1952
- var de_UpdateAdapterResponse = /* @__PURE__ */ __name((output, context) => {
1953
- return (0, import_smithy_client.take)(output, {
1954
- AdapterId: import_smithy_client.expectString,
1955
- AdapterName: import_smithy_client.expectString,
1956
- AutoUpdate: import_smithy_client.expectString,
1957
- CreationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
1958
- Description: import_smithy_client.expectString,
1959
- FeatureTypes: import_smithy_client._json
1960
- });
1961
- }, "de_UpdateAdapterResponse");
1962
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1963
- httpStatusCode: output.statusCode,
1964
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1965
- extendedRequestId: output.headers["x-amz-id-2"],
1966
- cfId: output.headers["x-amz-cf-id"]
1967
- }), "deserializeMetadata");
1968
- var throwDefaultError = (0, import_smithy_client.withBaseException)(TextractServiceException);
1969
- var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
1970
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1971
- const contents = {
1972
- protocol,
1973
- hostname,
1974
- port,
1975
- method: "POST",
1976
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
1977
- headers
1978
- };
1979
- if (resolvedHostname !== void 0) {
1980
- contents.hostname = resolvedHostname;
1981
- }
1982
- if (body !== void 0) {
1983
- contents.body = body;
1984
- }
1985
- return new import_protocol_http.HttpRequest(contents);
1986
- }, "buildHttpRpcRequest");
1987
- function sharedHeaders(operation) {
1988
- return {
1989
- "content-type": "application/x-amz-json-1.1",
1990
- "x-amz-target": `Textract.${operation}`
1991
- };
155
+ const BlockType = {
156
+ CELL: "CELL",
157
+ KEY_VALUE_SET: "KEY_VALUE_SET",
158
+ LAYOUT_FIGURE: "LAYOUT_FIGURE",
159
+ LAYOUT_FOOTER: "LAYOUT_FOOTER",
160
+ LAYOUT_HEADER: "LAYOUT_HEADER",
161
+ LAYOUT_KEY_VALUE: "LAYOUT_KEY_VALUE",
162
+ LAYOUT_LIST: "LAYOUT_LIST",
163
+ LAYOUT_PAGE_NUMBER: "LAYOUT_PAGE_NUMBER",
164
+ LAYOUT_SECTION_HEADER: "LAYOUT_SECTION_HEADER",
165
+ LAYOUT_TABLE: "LAYOUT_TABLE",
166
+ LAYOUT_TEXT: "LAYOUT_TEXT",
167
+ LAYOUT_TITLE: "LAYOUT_TITLE",
168
+ LINE: "LINE",
169
+ MERGED_CELL: "MERGED_CELL",
170
+ PAGE: "PAGE",
171
+ QUERY: "QUERY",
172
+ QUERY_RESULT: "QUERY_RESULT",
173
+ SELECTION_ELEMENT: "SELECTION_ELEMENT",
174
+ SIGNATURE: "SIGNATURE",
175
+ TABLE: "TABLE",
176
+ TABLE_FOOTER: "TABLE_FOOTER",
177
+ TABLE_TITLE: "TABLE_TITLE",
178
+ TITLE: "TITLE",
179
+ WORD: "WORD",
180
+ };
181
+ const EntityType = {
182
+ COLUMN_HEADER: "COLUMN_HEADER",
183
+ KEY: "KEY",
184
+ SEMI_STRUCTURED_TABLE: "SEMI_STRUCTURED_TABLE",
185
+ STRUCTURED_TABLE: "STRUCTURED_TABLE",
186
+ TABLE_FOOTER: "TABLE_FOOTER",
187
+ TABLE_SECTION_TITLE: "TABLE_SECTION_TITLE",
188
+ TABLE_SUMMARY: "TABLE_SUMMARY",
189
+ TABLE_TITLE: "TABLE_TITLE",
190
+ VALUE: "VALUE",
191
+ };
192
+ const RelationshipType = {
193
+ ANSWER: "ANSWER",
194
+ CHILD: "CHILD",
195
+ COMPLEX_FEATURES: "COMPLEX_FEATURES",
196
+ MERGED_CELL: "MERGED_CELL",
197
+ TABLE: "TABLE",
198
+ TABLE_FOOTER: "TABLE_FOOTER",
199
+ TABLE_TITLE: "TABLE_TITLE",
200
+ TITLE: "TITLE",
201
+ VALUE: "VALUE",
202
+ };
203
+ const SelectionStatus = {
204
+ NOT_SELECTED: "NOT_SELECTED",
205
+ SELECTED: "SELECTED",
206
+ };
207
+ const TextType = {
208
+ HANDWRITING: "HANDWRITING",
209
+ PRINTED: "PRINTED",
210
+ };
211
+ class BadDocumentException extends TextractServiceException {
212
+ name = "BadDocumentException";
213
+ $fault = "client";
214
+ Message;
215
+ Code;
216
+ constructor(opts) {
217
+ super({
218
+ name: "BadDocumentException",
219
+ $fault: "client",
220
+ ...opts,
221
+ });
222
+ Object.setPrototypeOf(this, BadDocumentException.prototype);
223
+ this.Message = opts.Message;
224
+ this.Code = opts.Code;
225
+ }
1992
226
  }
1993
- __name(sharedHeaders, "sharedHeaders");
1994
-
1995
- // src/commands/AnalyzeDocumentCommand.ts
1996
- var AnalyzeDocumentCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1997
- return [
1998
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1999
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2000
- ];
2001
- }).s("Textract", "AnalyzeDocument", {}).n("TextractClient", "AnalyzeDocumentCommand").f(void 0, void 0).ser(se_AnalyzeDocumentCommand).de(de_AnalyzeDocumentCommand).build() {
2002
- static {
2003
- __name(this, "AnalyzeDocumentCommand");
2004
- }
227
+ class DocumentTooLargeException extends TextractServiceException {
228
+ name = "DocumentTooLargeException";
229
+ $fault = "client";
230
+ Message;
231
+ Code;
232
+ constructor(opts) {
233
+ super({
234
+ name: "DocumentTooLargeException",
235
+ $fault: "client",
236
+ ...opts,
237
+ });
238
+ Object.setPrototypeOf(this, DocumentTooLargeException.prototype);
239
+ this.Message = opts.Message;
240
+ this.Code = opts.Code;
241
+ }
242
+ }
243
+ class HumanLoopQuotaExceededException extends TextractServiceException {
244
+ name = "HumanLoopQuotaExceededException";
245
+ $fault = "client";
246
+ ResourceType;
247
+ QuotaCode;
248
+ ServiceCode;
249
+ Message;
250
+ Code;
251
+ constructor(opts) {
252
+ super({
253
+ name: "HumanLoopQuotaExceededException",
254
+ $fault: "client",
255
+ ...opts,
256
+ });
257
+ Object.setPrototypeOf(this, HumanLoopQuotaExceededException.prototype);
258
+ this.ResourceType = opts.ResourceType;
259
+ this.QuotaCode = opts.QuotaCode;
260
+ this.ServiceCode = opts.ServiceCode;
261
+ this.Message = opts.Message;
262
+ this.Code = opts.Code;
263
+ }
264
+ }
265
+ class InternalServerError extends TextractServiceException {
266
+ name = "InternalServerError";
267
+ $fault = "server";
268
+ Message;
269
+ Code;
270
+ constructor(opts) {
271
+ super({
272
+ name: "InternalServerError",
273
+ $fault: "server",
274
+ ...opts,
275
+ });
276
+ Object.setPrototypeOf(this, InternalServerError.prototype);
277
+ this.Message = opts.Message;
278
+ this.Code = opts.Code;
279
+ }
280
+ }
281
+ class InvalidParameterException extends TextractServiceException {
282
+ name = "InvalidParameterException";
283
+ $fault = "client";
284
+ Message;
285
+ Code;
286
+ constructor(opts) {
287
+ super({
288
+ name: "InvalidParameterException",
289
+ $fault: "client",
290
+ ...opts,
291
+ });
292
+ Object.setPrototypeOf(this, InvalidParameterException.prototype);
293
+ this.Message = opts.Message;
294
+ this.Code = opts.Code;
295
+ }
296
+ }
297
+ class InvalidS3ObjectException extends TextractServiceException {
298
+ name = "InvalidS3ObjectException";
299
+ $fault = "client";
300
+ Message;
301
+ Code;
302
+ constructor(opts) {
303
+ super({
304
+ name: "InvalidS3ObjectException",
305
+ $fault: "client",
306
+ ...opts,
307
+ });
308
+ Object.setPrototypeOf(this, InvalidS3ObjectException.prototype);
309
+ this.Message = opts.Message;
310
+ this.Code = opts.Code;
311
+ }
312
+ }
313
+ class ProvisionedThroughputExceededException extends TextractServiceException {
314
+ name = "ProvisionedThroughputExceededException";
315
+ $fault = "client";
316
+ Message;
317
+ Code;
318
+ constructor(opts) {
319
+ super({
320
+ name: "ProvisionedThroughputExceededException",
321
+ $fault: "client",
322
+ ...opts,
323
+ });
324
+ Object.setPrototypeOf(this, ProvisionedThroughputExceededException.prototype);
325
+ this.Message = opts.Message;
326
+ this.Code = opts.Code;
327
+ }
328
+ }
329
+ class ThrottlingException extends TextractServiceException {
330
+ name = "ThrottlingException";
331
+ $fault = "server";
332
+ Message;
333
+ Code;
334
+ constructor(opts) {
335
+ super({
336
+ name: "ThrottlingException",
337
+ $fault: "server",
338
+ ...opts,
339
+ });
340
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
341
+ this.Message = opts.Message;
342
+ this.Code = opts.Code;
343
+ }
344
+ }
345
+ class UnsupportedDocumentException extends TextractServiceException {
346
+ name = "UnsupportedDocumentException";
347
+ $fault = "client";
348
+ Message;
349
+ Code;
350
+ constructor(opts) {
351
+ super({
352
+ name: "UnsupportedDocumentException",
353
+ $fault: "client",
354
+ ...opts,
355
+ });
356
+ Object.setPrototypeOf(this, UnsupportedDocumentException.prototype);
357
+ this.Message = opts.Message;
358
+ this.Code = opts.Code;
359
+ }
360
+ }
361
+ const ValueType = {
362
+ DATE: "DATE",
2005
363
  };
2006
-
2007
- // src/commands/AnalyzeExpenseCommand.ts
2008
-
2009
-
2010
-
2011
- var AnalyzeExpenseCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2012
- return [
2013
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2014
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2015
- ];
2016
- }).s("Textract", "AnalyzeExpense", {}).n("TextractClient", "AnalyzeExpenseCommand").f(void 0, void 0).ser(se_AnalyzeExpenseCommand).de(de_AnalyzeExpenseCommand).build() {
2017
- static {
2018
- __name(this, "AnalyzeExpenseCommand");
2019
- }
364
+ const AutoUpdate = {
365
+ DISABLED: "DISABLED",
366
+ ENABLED: "ENABLED",
2020
367
  };
2021
-
2022
- // src/commands/AnalyzeIDCommand.ts
2023
-
2024
-
2025
-
2026
- var AnalyzeIDCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2027
- return [
2028
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2029
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2030
- ];
2031
- }).s("Textract", "AnalyzeID", {}).n("TextractClient", "AnalyzeIDCommand").f(void 0, void 0).ser(se_AnalyzeIDCommand).de(de_AnalyzeIDCommand).build() {
2032
- static {
2033
- __name(this, "AnalyzeIDCommand");
2034
- }
368
+ class ConflictException extends TextractServiceException {
369
+ name = "ConflictException";
370
+ $fault = "client";
371
+ Message;
372
+ Code;
373
+ constructor(opts) {
374
+ super({
375
+ name: "ConflictException",
376
+ $fault: "client",
377
+ ...opts,
378
+ });
379
+ Object.setPrototypeOf(this, ConflictException.prototype);
380
+ this.Message = opts.Message;
381
+ this.Code = opts.Code;
382
+ }
383
+ }
384
+ class IdempotentParameterMismatchException extends TextractServiceException {
385
+ name = "IdempotentParameterMismatchException";
386
+ $fault = "client";
387
+ Message;
388
+ Code;
389
+ constructor(opts) {
390
+ super({
391
+ name: "IdempotentParameterMismatchException",
392
+ $fault: "client",
393
+ ...opts,
394
+ });
395
+ Object.setPrototypeOf(this, IdempotentParameterMismatchException.prototype);
396
+ this.Message = opts.Message;
397
+ this.Code = opts.Code;
398
+ }
399
+ }
400
+ class LimitExceededException extends TextractServiceException {
401
+ name = "LimitExceededException";
402
+ $fault = "client";
403
+ Message;
404
+ Code;
405
+ constructor(opts) {
406
+ super({
407
+ name: "LimitExceededException",
408
+ $fault: "client",
409
+ ...opts,
410
+ });
411
+ Object.setPrototypeOf(this, LimitExceededException.prototype);
412
+ this.Message = opts.Message;
413
+ this.Code = opts.Code;
414
+ }
415
+ }
416
+ class ServiceQuotaExceededException extends TextractServiceException {
417
+ name = "ServiceQuotaExceededException";
418
+ $fault = "client";
419
+ Message;
420
+ Code;
421
+ constructor(opts) {
422
+ super({
423
+ name: "ServiceQuotaExceededException",
424
+ $fault: "client",
425
+ ...opts,
426
+ });
427
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
428
+ this.Message = opts.Message;
429
+ this.Code = opts.Code;
430
+ }
431
+ }
432
+ class ValidationException extends TextractServiceException {
433
+ name = "ValidationException";
434
+ $fault = "client";
435
+ Message;
436
+ Code;
437
+ constructor(opts) {
438
+ super({
439
+ name: "ValidationException",
440
+ $fault: "client",
441
+ ...opts,
442
+ });
443
+ Object.setPrototypeOf(this, ValidationException.prototype);
444
+ this.Message = opts.Message;
445
+ this.Code = opts.Code;
446
+ }
447
+ }
448
+ class InvalidKMSKeyException extends TextractServiceException {
449
+ name = "InvalidKMSKeyException";
450
+ $fault = "client";
451
+ Message;
452
+ Code;
453
+ constructor(opts) {
454
+ super({
455
+ name: "InvalidKMSKeyException",
456
+ $fault: "client",
457
+ ...opts,
458
+ });
459
+ Object.setPrototypeOf(this, InvalidKMSKeyException.prototype);
460
+ this.Message = opts.Message;
461
+ this.Code = opts.Code;
462
+ }
463
+ }
464
+ class ResourceNotFoundException extends TextractServiceException {
465
+ name = "ResourceNotFoundException";
466
+ $fault = "client";
467
+ Message;
468
+ Code;
469
+ constructor(opts) {
470
+ super({
471
+ name: "ResourceNotFoundException",
472
+ $fault: "client",
473
+ ...opts,
474
+ });
475
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
476
+ this.Message = opts.Message;
477
+ this.Code = opts.Code;
478
+ }
479
+ }
480
+ const JobStatus = {
481
+ FAILED: "FAILED",
482
+ IN_PROGRESS: "IN_PROGRESS",
483
+ PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
484
+ SUCCEEDED: "SUCCEEDED",
2035
485
  };
486
+ class InvalidJobIdException extends TextractServiceException {
487
+ name = "InvalidJobIdException";
488
+ $fault = "client";
489
+ Message;
490
+ Code;
491
+ constructor(opts) {
492
+ super({
493
+ name: "InvalidJobIdException",
494
+ $fault: "client",
495
+ ...opts,
496
+ });
497
+ Object.setPrototypeOf(this, InvalidJobIdException.prototype);
498
+ this.Message = opts.Message;
499
+ this.Code = opts.Code;
500
+ }
501
+ }
2036
502
 
2037
- // src/commands/CreateAdapterCommand.ts
2038
-
2039
-
2040
-
2041
- var CreateAdapterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2042
- return [
2043
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2044
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2045
- ];
2046
- }).s("Textract", "CreateAdapter", {}).n("TextractClient", "CreateAdapterCommand").f(void 0, void 0).ser(se_CreateAdapterCommand).de(de_CreateAdapterCommand).build() {
2047
- static {
2048
- __name(this, "CreateAdapterCommand");
2049
- }
503
+ const se_AnalyzeDocumentCommand = async (input, context) => {
504
+ const headers = sharedHeaders("AnalyzeDocument");
505
+ let body;
506
+ body = JSON.stringify(se_AnalyzeDocumentRequest(input, context));
507
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2050
508
  };
2051
-
2052
- // src/commands/CreateAdapterVersionCommand.ts
2053
-
2054
-
2055
-
2056
- var CreateAdapterVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2057
- return [
2058
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2059
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2060
- ];
2061
- }).s("Textract", "CreateAdapterVersion", {}).n("TextractClient", "CreateAdapterVersionCommand").f(void 0, void 0).ser(se_CreateAdapterVersionCommand).de(de_CreateAdapterVersionCommand).build() {
2062
- static {
2063
- __name(this, "CreateAdapterVersionCommand");
2064
- }
509
+ const se_AnalyzeExpenseCommand = async (input, context) => {
510
+ const headers = sharedHeaders("AnalyzeExpense");
511
+ let body;
512
+ body = JSON.stringify(se_AnalyzeExpenseRequest(input, context));
513
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2065
514
  };
2066
-
2067
- // src/commands/DeleteAdapterCommand.ts
2068
-
2069
-
2070
-
2071
- var DeleteAdapterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2072
- return [
2073
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2074
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2075
- ];
2076
- }).s("Textract", "DeleteAdapter", {}).n("TextractClient", "DeleteAdapterCommand").f(void 0, void 0).ser(se_DeleteAdapterCommand).de(de_DeleteAdapterCommand).build() {
2077
- static {
2078
- __name(this, "DeleteAdapterCommand");
2079
- }
515
+ const se_AnalyzeIDCommand = async (input, context) => {
516
+ const headers = sharedHeaders("AnalyzeID");
517
+ let body;
518
+ body = JSON.stringify(se_AnalyzeIDRequest(input, context));
519
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2080
520
  };
2081
-
2082
- // src/commands/DeleteAdapterVersionCommand.ts
2083
-
2084
-
2085
-
2086
- var DeleteAdapterVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2087
- return [
2088
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2089
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2090
- ];
2091
- }).s("Textract", "DeleteAdapterVersion", {}).n("TextractClient", "DeleteAdapterVersionCommand").f(void 0, void 0).ser(se_DeleteAdapterVersionCommand).de(de_DeleteAdapterVersionCommand).build() {
2092
- static {
2093
- __name(this, "DeleteAdapterVersionCommand");
2094
- }
521
+ const se_CreateAdapterCommand = async (input, context) => {
522
+ const headers = sharedHeaders("CreateAdapter");
523
+ let body;
524
+ body = JSON.stringify(se_CreateAdapterRequest(input));
525
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2095
526
  };
2096
-
2097
- // src/commands/DetectDocumentTextCommand.ts
2098
-
2099
-
2100
-
2101
- var DetectDocumentTextCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2102
- return [
2103
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2104
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2105
- ];
2106
- }).s("Textract", "DetectDocumentText", {}).n("TextractClient", "DetectDocumentTextCommand").f(void 0, void 0).ser(se_DetectDocumentTextCommand).de(de_DetectDocumentTextCommand).build() {
2107
- static {
2108
- __name(this, "DetectDocumentTextCommand");
2109
- }
527
+ const se_CreateAdapterVersionCommand = async (input, context) => {
528
+ const headers = sharedHeaders("CreateAdapterVersion");
529
+ let body;
530
+ body = JSON.stringify(se_CreateAdapterVersionRequest(input));
531
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2110
532
  };
2111
-
2112
- // src/commands/GetAdapterCommand.ts
2113
-
2114
-
2115
-
2116
- var GetAdapterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2117
- return [
2118
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2119
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2120
- ];
2121
- }).s("Textract", "GetAdapter", {}).n("TextractClient", "GetAdapterCommand").f(void 0, void 0).ser(se_GetAdapterCommand).de(de_GetAdapterCommand).build() {
2122
- static {
2123
- __name(this, "GetAdapterCommand");
2124
- }
533
+ const se_DeleteAdapterCommand = async (input, context) => {
534
+ const headers = sharedHeaders("DeleteAdapter");
535
+ let body;
536
+ body = JSON.stringify(smithyClient._json(input));
537
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2125
538
  };
2126
-
2127
- // src/commands/GetAdapterVersionCommand.ts
2128
-
2129
-
2130
-
2131
- var GetAdapterVersionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2132
- return [
2133
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2134
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2135
- ];
2136
- }).s("Textract", "GetAdapterVersion", {}).n("TextractClient", "GetAdapterVersionCommand").f(void 0, void 0).ser(se_GetAdapterVersionCommand).de(de_GetAdapterVersionCommand).build() {
2137
- static {
2138
- __name(this, "GetAdapterVersionCommand");
2139
- }
539
+ const se_DeleteAdapterVersionCommand = async (input, context) => {
540
+ const headers = sharedHeaders("DeleteAdapterVersion");
541
+ let body;
542
+ body = JSON.stringify(smithyClient._json(input));
543
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2140
544
  };
2141
-
2142
- // src/commands/GetDocumentAnalysisCommand.ts
2143
-
2144
-
2145
-
2146
- var GetDocumentAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2147
- return [
2148
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2149
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2150
- ];
2151
- }).s("Textract", "GetDocumentAnalysis", {}).n("TextractClient", "GetDocumentAnalysisCommand").f(void 0, void 0).ser(se_GetDocumentAnalysisCommand).de(de_GetDocumentAnalysisCommand).build() {
2152
- static {
2153
- __name(this, "GetDocumentAnalysisCommand");
2154
- }
545
+ const se_DetectDocumentTextCommand = async (input, context) => {
546
+ const headers = sharedHeaders("DetectDocumentText");
547
+ let body;
548
+ body = JSON.stringify(se_DetectDocumentTextRequest(input, context));
549
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2155
550
  };
2156
-
2157
- // src/commands/GetDocumentTextDetectionCommand.ts
2158
-
2159
-
2160
-
2161
- var GetDocumentTextDetectionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2162
- return [
2163
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2164
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2165
- ];
2166
- }).s("Textract", "GetDocumentTextDetection", {}).n("TextractClient", "GetDocumentTextDetectionCommand").f(void 0, void 0).ser(se_GetDocumentTextDetectionCommand).de(de_GetDocumentTextDetectionCommand).build() {
2167
- static {
2168
- __name(this, "GetDocumentTextDetectionCommand");
2169
- }
551
+ const se_GetAdapterCommand = async (input, context) => {
552
+ const headers = sharedHeaders("GetAdapter");
553
+ let body;
554
+ body = JSON.stringify(smithyClient._json(input));
555
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2170
556
  };
2171
-
2172
- // src/commands/GetExpenseAnalysisCommand.ts
2173
-
2174
-
2175
-
2176
- var GetExpenseAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2177
- return [
2178
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2179
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2180
- ];
2181
- }).s("Textract", "GetExpenseAnalysis", {}).n("TextractClient", "GetExpenseAnalysisCommand").f(void 0, void 0).ser(se_GetExpenseAnalysisCommand).de(de_GetExpenseAnalysisCommand).build() {
2182
- static {
2183
- __name(this, "GetExpenseAnalysisCommand");
2184
- }
557
+ const se_GetAdapterVersionCommand = async (input, context) => {
558
+ const headers = sharedHeaders("GetAdapterVersion");
559
+ let body;
560
+ body = JSON.stringify(smithyClient._json(input));
561
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2185
562
  };
2186
-
2187
- // src/commands/GetLendingAnalysisCommand.ts
2188
-
2189
-
2190
-
2191
- var GetLendingAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2192
- return [
2193
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2194
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2195
- ];
2196
- }).s("Textract", "GetLendingAnalysis", {}).n("TextractClient", "GetLendingAnalysisCommand").f(void 0, void 0).ser(se_GetLendingAnalysisCommand).de(de_GetLendingAnalysisCommand).build() {
2197
- static {
2198
- __name(this, "GetLendingAnalysisCommand");
2199
- }
563
+ const se_GetDocumentAnalysisCommand = async (input, context) => {
564
+ const headers = sharedHeaders("GetDocumentAnalysis");
565
+ let body;
566
+ body = JSON.stringify(smithyClient._json(input));
567
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2200
568
  };
2201
-
2202
- // src/commands/GetLendingAnalysisSummaryCommand.ts
2203
-
2204
-
2205
-
2206
- var GetLendingAnalysisSummaryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2207
- return [
2208
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2209
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2210
- ];
2211
- }).s("Textract", "GetLendingAnalysisSummary", {}).n("TextractClient", "GetLendingAnalysisSummaryCommand").f(void 0, void 0).ser(se_GetLendingAnalysisSummaryCommand).de(de_GetLendingAnalysisSummaryCommand).build() {
2212
- static {
2213
- __name(this, "GetLendingAnalysisSummaryCommand");
2214
- }
569
+ const se_GetDocumentTextDetectionCommand = async (input, context) => {
570
+ const headers = sharedHeaders("GetDocumentTextDetection");
571
+ let body;
572
+ body = JSON.stringify(smithyClient._json(input));
573
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2215
574
  };
2216
-
2217
- // src/commands/ListAdaptersCommand.ts
2218
-
2219
-
2220
-
2221
- var ListAdaptersCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2222
- return [
2223
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2224
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2225
- ];
2226
- }).s("Textract", "ListAdapters", {}).n("TextractClient", "ListAdaptersCommand").f(void 0, void 0).ser(se_ListAdaptersCommand).de(de_ListAdaptersCommand).build() {
2227
- static {
2228
- __name(this, "ListAdaptersCommand");
2229
- }
575
+ const se_GetExpenseAnalysisCommand = async (input, context) => {
576
+ const headers = sharedHeaders("GetExpenseAnalysis");
577
+ let body;
578
+ body = JSON.stringify(smithyClient._json(input));
579
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2230
580
  };
2231
-
2232
- // src/commands/ListAdapterVersionsCommand.ts
2233
-
2234
-
2235
-
2236
- var ListAdapterVersionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2237
- return [
2238
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2239
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2240
- ];
2241
- }).s("Textract", "ListAdapterVersions", {}).n("TextractClient", "ListAdapterVersionsCommand").f(void 0, void 0).ser(se_ListAdapterVersionsCommand).de(de_ListAdapterVersionsCommand).build() {
2242
- static {
2243
- __name(this, "ListAdapterVersionsCommand");
2244
- }
581
+ const se_GetLendingAnalysisCommand = async (input, context) => {
582
+ const headers = sharedHeaders("GetLendingAnalysis");
583
+ let body;
584
+ body = JSON.stringify(smithyClient._json(input));
585
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2245
586
  };
2246
-
2247
- // src/commands/ListTagsForResourceCommand.ts
2248
-
2249
-
2250
-
2251
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2252
- return [
2253
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2254
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2255
- ];
2256
- }).s("Textract", "ListTagsForResource", {}).n("TextractClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
2257
- static {
2258
- __name(this, "ListTagsForResourceCommand");
2259
- }
587
+ const se_GetLendingAnalysisSummaryCommand = async (input, context) => {
588
+ const headers = sharedHeaders("GetLendingAnalysisSummary");
589
+ let body;
590
+ body = JSON.stringify(smithyClient._json(input));
591
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2260
592
  };
2261
-
2262
- // src/commands/StartDocumentAnalysisCommand.ts
2263
-
2264
-
2265
-
2266
- var StartDocumentAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2267
- return [
2268
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2269
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2270
- ];
2271
- }).s("Textract", "StartDocumentAnalysis", {}).n("TextractClient", "StartDocumentAnalysisCommand").f(void 0, void 0).ser(se_StartDocumentAnalysisCommand).de(de_StartDocumentAnalysisCommand).build() {
2272
- static {
2273
- __name(this, "StartDocumentAnalysisCommand");
2274
- }
593
+ const se_ListAdaptersCommand = async (input, context) => {
594
+ const headers = sharedHeaders("ListAdapters");
595
+ let body;
596
+ body = JSON.stringify(se_ListAdaptersRequest(input));
597
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
2275
598
  };
599
+ const se_ListAdapterVersionsCommand = async (input, context) => {
600
+ const headers = sharedHeaders("ListAdapterVersions");
601
+ let body;
602
+ body = JSON.stringify(se_ListAdapterVersionsRequest(input));
603
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
604
+ };
605
+ const se_ListTagsForResourceCommand = async (input, context) => {
606
+ const headers = sharedHeaders("ListTagsForResource");
607
+ let body;
608
+ body = JSON.stringify(smithyClient._json(input));
609
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
610
+ };
611
+ const se_StartDocumentAnalysisCommand = async (input, context) => {
612
+ const headers = sharedHeaders("StartDocumentAnalysis");
613
+ let body;
614
+ body = JSON.stringify(smithyClient._json(input));
615
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
616
+ };
617
+ const se_StartDocumentTextDetectionCommand = async (input, context) => {
618
+ const headers = sharedHeaders("StartDocumentTextDetection");
619
+ let body;
620
+ body = JSON.stringify(smithyClient._json(input));
621
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
622
+ };
623
+ const se_StartExpenseAnalysisCommand = async (input, context) => {
624
+ const headers = sharedHeaders("StartExpenseAnalysis");
625
+ let body;
626
+ body = JSON.stringify(smithyClient._json(input));
627
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
628
+ };
629
+ const se_StartLendingAnalysisCommand = async (input, context) => {
630
+ const headers = sharedHeaders("StartLendingAnalysis");
631
+ let body;
632
+ body = JSON.stringify(smithyClient._json(input));
633
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
634
+ };
635
+ const se_TagResourceCommand = async (input, context) => {
636
+ const headers = sharedHeaders("TagResource");
637
+ let body;
638
+ body = JSON.stringify(smithyClient._json(input));
639
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
640
+ };
641
+ const se_UntagResourceCommand = async (input, context) => {
642
+ const headers = sharedHeaders("UntagResource");
643
+ let body;
644
+ body = JSON.stringify(smithyClient._json(input));
645
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
646
+ };
647
+ const se_UpdateAdapterCommand = async (input, context) => {
648
+ const headers = sharedHeaders("UpdateAdapter");
649
+ let body;
650
+ body = JSON.stringify(smithyClient._json(input));
651
+ return buildHttpRpcRequest(context, headers, "/", undefined, body);
652
+ };
653
+ const de_AnalyzeDocumentCommand = async (output, context) => {
654
+ if (output.statusCode >= 300) {
655
+ return de_CommandError(output, context);
656
+ }
657
+ const data = await core$1.parseJsonBody(output.body, context);
658
+ let contents = {};
659
+ contents = de_AnalyzeDocumentResponse(data);
660
+ const response = {
661
+ $metadata: deserializeMetadata(output),
662
+ ...contents,
663
+ };
664
+ return response;
665
+ };
666
+ const de_AnalyzeExpenseCommand = async (output, context) => {
667
+ if (output.statusCode >= 300) {
668
+ return de_CommandError(output, context);
669
+ }
670
+ const data = await core$1.parseJsonBody(output.body, context);
671
+ let contents = {};
672
+ contents = de_AnalyzeExpenseResponse(data);
673
+ const response = {
674
+ $metadata: deserializeMetadata(output),
675
+ ...contents,
676
+ };
677
+ return response;
678
+ };
679
+ const de_AnalyzeIDCommand = async (output, context) => {
680
+ if (output.statusCode >= 300) {
681
+ return de_CommandError(output, context);
682
+ }
683
+ const data = await core$1.parseJsonBody(output.body, context);
684
+ let contents = {};
685
+ contents = de_AnalyzeIDResponse(data);
686
+ const response = {
687
+ $metadata: deserializeMetadata(output),
688
+ ...contents,
689
+ };
690
+ return response;
691
+ };
692
+ const de_CreateAdapterCommand = async (output, context) => {
693
+ if (output.statusCode >= 300) {
694
+ return de_CommandError(output, context);
695
+ }
696
+ const data = await core$1.parseJsonBody(output.body, context);
697
+ let contents = {};
698
+ contents = smithyClient._json(data);
699
+ const response = {
700
+ $metadata: deserializeMetadata(output),
701
+ ...contents,
702
+ };
703
+ return response;
704
+ };
705
+ const de_CreateAdapterVersionCommand = async (output, context) => {
706
+ if (output.statusCode >= 300) {
707
+ return de_CommandError(output, context);
708
+ }
709
+ const data = await core$1.parseJsonBody(output.body, context);
710
+ let contents = {};
711
+ contents = smithyClient._json(data);
712
+ const response = {
713
+ $metadata: deserializeMetadata(output),
714
+ ...contents,
715
+ };
716
+ return response;
717
+ };
718
+ const de_DeleteAdapterCommand = async (output, context) => {
719
+ if (output.statusCode >= 300) {
720
+ return de_CommandError(output, context);
721
+ }
722
+ const data = await core$1.parseJsonBody(output.body, context);
723
+ let contents = {};
724
+ contents = smithyClient._json(data);
725
+ const response = {
726
+ $metadata: deserializeMetadata(output),
727
+ ...contents,
728
+ };
729
+ return response;
730
+ };
731
+ const de_DeleteAdapterVersionCommand = async (output, context) => {
732
+ if (output.statusCode >= 300) {
733
+ return de_CommandError(output, context);
734
+ }
735
+ const data = await core$1.parseJsonBody(output.body, context);
736
+ let contents = {};
737
+ contents = smithyClient._json(data);
738
+ const response = {
739
+ $metadata: deserializeMetadata(output),
740
+ ...contents,
741
+ };
742
+ return response;
743
+ };
744
+ const de_DetectDocumentTextCommand = async (output, context) => {
745
+ if (output.statusCode >= 300) {
746
+ return de_CommandError(output, context);
747
+ }
748
+ const data = await core$1.parseJsonBody(output.body, context);
749
+ let contents = {};
750
+ contents = de_DetectDocumentTextResponse(data);
751
+ const response = {
752
+ $metadata: deserializeMetadata(output),
753
+ ...contents,
754
+ };
755
+ return response;
756
+ };
757
+ const de_GetAdapterCommand = async (output, context) => {
758
+ if (output.statusCode >= 300) {
759
+ return de_CommandError(output, context);
760
+ }
761
+ const data = await core$1.parseJsonBody(output.body, context);
762
+ let contents = {};
763
+ contents = de_GetAdapterResponse(data);
764
+ const response = {
765
+ $metadata: deserializeMetadata(output),
766
+ ...contents,
767
+ };
768
+ return response;
769
+ };
770
+ const de_GetAdapterVersionCommand = async (output, context) => {
771
+ if (output.statusCode >= 300) {
772
+ return de_CommandError(output, context);
773
+ }
774
+ const data = await core$1.parseJsonBody(output.body, context);
775
+ let contents = {};
776
+ contents = de_GetAdapterVersionResponse(data);
777
+ const response = {
778
+ $metadata: deserializeMetadata(output),
779
+ ...contents,
780
+ };
781
+ return response;
782
+ };
783
+ const de_GetDocumentAnalysisCommand = async (output, context) => {
784
+ if (output.statusCode >= 300) {
785
+ return de_CommandError(output, context);
786
+ }
787
+ const data = await core$1.parseJsonBody(output.body, context);
788
+ let contents = {};
789
+ contents = de_GetDocumentAnalysisResponse(data);
790
+ const response = {
791
+ $metadata: deserializeMetadata(output),
792
+ ...contents,
793
+ };
794
+ return response;
795
+ };
796
+ const de_GetDocumentTextDetectionCommand = async (output, context) => {
797
+ if (output.statusCode >= 300) {
798
+ return de_CommandError(output, context);
799
+ }
800
+ const data = await core$1.parseJsonBody(output.body, context);
801
+ let contents = {};
802
+ contents = de_GetDocumentTextDetectionResponse(data);
803
+ const response = {
804
+ $metadata: deserializeMetadata(output),
805
+ ...contents,
806
+ };
807
+ return response;
808
+ };
809
+ const de_GetExpenseAnalysisCommand = async (output, context) => {
810
+ if (output.statusCode >= 300) {
811
+ return de_CommandError(output, context);
812
+ }
813
+ const data = await core$1.parseJsonBody(output.body, context);
814
+ let contents = {};
815
+ contents = de_GetExpenseAnalysisResponse(data);
816
+ const response = {
817
+ $metadata: deserializeMetadata(output),
818
+ ...contents,
819
+ };
820
+ return response;
821
+ };
822
+ const de_GetLendingAnalysisCommand = async (output, context) => {
823
+ if (output.statusCode >= 300) {
824
+ return de_CommandError(output, context);
825
+ }
826
+ const data = await core$1.parseJsonBody(output.body, context);
827
+ let contents = {};
828
+ contents = de_GetLendingAnalysisResponse(data);
829
+ const response = {
830
+ $metadata: deserializeMetadata(output),
831
+ ...contents,
832
+ };
833
+ return response;
834
+ };
835
+ const de_GetLendingAnalysisSummaryCommand = async (output, context) => {
836
+ if (output.statusCode >= 300) {
837
+ return de_CommandError(output, context);
838
+ }
839
+ const data = await core$1.parseJsonBody(output.body, context);
840
+ let contents = {};
841
+ contents = smithyClient._json(data);
842
+ const response = {
843
+ $metadata: deserializeMetadata(output),
844
+ ...contents,
845
+ };
846
+ return response;
847
+ };
848
+ const de_ListAdaptersCommand = async (output, context) => {
849
+ if (output.statusCode >= 300) {
850
+ return de_CommandError(output, context);
851
+ }
852
+ const data = await core$1.parseJsonBody(output.body, context);
853
+ let contents = {};
854
+ contents = de_ListAdaptersResponse(data);
855
+ const response = {
856
+ $metadata: deserializeMetadata(output),
857
+ ...contents,
858
+ };
859
+ return response;
860
+ };
861
+ const de_ListAdapterVersionsCommand = async (output, context) => {
862
+ if (output.statusCode >= 300) {
863
+ return de_CommandError(output, context);
864
+ }
865
+ const data = await core$1.parseJsonBody(output.body, context);
866
+ let contents = {};
867
+ contents = de_ListAdapterVersionsResponse(data);
868
+ const response = {
869
+ $metadata: deserializeMetadata(output),
870
+ ...contents,
871
+ };
872
+ return response;
873
+ };
874
+ const de_ListTagsForResourceCommand = async (output, context) => {
875
+ if (output.statusCode >= 300) {
876
+ return de_CommandError(output, context);
877
+ }
878
+ const data = await core$1.parseJsonBody(output.body, context);
879
+ let contents = {};
880
+ contents = smithyClient._json(data);
881
+ const response = {
882
+ $metadata: deserializeMetadata(output),
883
+ ...contents,
884
+ };
885
+ return response;
886
+ };
887
+ const de_StartDocumentAnalysisCommand = async (output, context) => {
888
+ if (output.statusCode >= 300) {
889
+ return de_CommandError(output, context);
890
+ }
891
+ const data = await core$1.parseJsonBody(output.body, context);
892
+ let contents = {};
893
+ contents = smithyClient._json(data);
894
+ const response = {
895
+ $metadata: deserializeMetadata(output),
896
+ ...contents,
897
+ };
898
+ return response;
899
+ };
900
+ const de_StartDocumentTextDetectionCommand = async (output, context) => {
901
+ if (output.statusCode >= 300) {
902
+ return de_CommandError(output, context);
903
+ }
904
+ const data = await core$1.parseJsonBody(output.body, context);
905
+ let contents = {};
906
+ contents = smithyClient._json(data);
907
+ const response = {
908
+ $metadata: deserializeMetadata(output),
909
+ ...contents,
910
+ };
911
+ return response;
912
+ };
913
+ const de_StartExpenseAnalysisCommand = async (output, context) => {
914
+ if (output.statusCode >= 300) {
915
+ return de_CommandError(output, context);
916
+ }
917
+ const data = await core$1.parseJsonBody(output.body, context);
918
+ let contents = {};
919
+ contents = smithyClient._json(data);
920
+ const response = {
921
+ $metadata: deserializeMetadata(output),
922
+ ...contents,
923
+ };
924
+ return response;
925
+ };
926
+ const de_StartLendingAnalysisCommand = async (output, context) => {
927
+ if (output.statusCode >= 300) {
928
+ return de_CommandError(output, context);
929
+ }
930
+ const data = await core$1.parseJsonBody(output.body, context);
931
+ let contents = {};
932
+ contents = smithyClient._json(data);
933
+ const response = {
934
+ $metadata: deserializeMetadata(output),
935
+ ...contents,
936
+ };
937
+ return response;
938
+ };
939
+ const de_TagResourceCommand = async (output, context) => {
940
+ if (output.statusCode >= 300) {
941
+ return de_CommandError(output, context);
942
+ }
943
+ const data = await core$1.parseJsonBody(output.body, context);
944
+ let contents = {};
945
+ contents = smithyClient._json(data);
946
+ const response = {
947
+ $metadata: deserializeMetadata(output),
948
+ ...contents,
949
+ };
950
+ return response;
951
+ };
952
+ const de_UntagResourceCommand = async (output, context) => {
953
+ if (output.statusCode >= 300) {
954
+ return de_CommandError(output, context);
955
+ }
956
+ const data = await core$1.parseJsonBody(output.body, context);
957
+ let contents = {};
958
+ contents = smithyClient._json(data);
959
+ const response = {
960
+ $metadata: deserializeMetadata(output),
961
+ ...contents,
962
+ };
963
+ return response;
964
+ };
965
+ const de_UpdateAdapterCommand = async (output, context) => {
966
+ if (output.statusCode >= 300) {
967
+ return de_CommandError(output, context);
968
+ }
969
+ const data = await core$1.parseJsonBody(output.body, context);
970
+ let contents = {};
971
+ contents = de_UpdateAdapterResponse(data);
972
+ const response = {
973
+ $metadata: deserializeMetadata(output),
974
+ ...contents,
975
+ };
976
+ return response;
977
+ };
978
+ const de_CommandError = async (output, context) => {
979
+ const parsedOutput = {
980
+ ...output,
981
+ body: await core$1.parseJsonErrorBody(output.body, context),
982
+ };
983
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
984
+ switch (errorCode) {
985
+ case "AccessDeniedException":
986
+ case "com.amazonaws.textract#AccessDeniedException":
987
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
988
+ case "BadDocumentException":
989
+ case "com.amazonaws.textract#BadDocumentException":
990
+ throw await de_BadDocumentExceptionRes(parsedOutput);
991
+ case "DocumentTooLargeException":
992
+ case "com.amazonaws.textract#DocumentTooLargeException":
993
+ throw await de_DocumentTooLargeExceptionRes(parsedOutput);
994
+ case "HumanLoopQuotaExceededException":
995
+ case "com.amazonaws.textract#HumanLoopQuotaExceededException":
996
+ throw await de_HumanLoopQuotaExceededExceptionRes(parsedOutput);
997
+ case "InternalServerError":
998
+ case "com.amazonaws.textract#InternalServerError":
999
+ throw await de_InternalServerErrorRes(parsedOutput);
1000
+ case "InvalidParameterException":
1001
+ case "com.amazonaws.textract#InvalidParameterException":
1002
+ throw await de_InvalidParameterExceptionRes(parsedOutput);
1003
+ case "InvalidS3ObjectException":
1004
+ case "com.amazonaws.textract#InvalidS3ObjectException":
1005
+ throw await de_InvalidS3ObjectExceptionRes(parsedOutput);
1006
+ case "ProvisionedThroughputExceededException":
1007
+ case "com.amazonaws.textract#ProvisionedThroughputExceededException":
1008
+ throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput);
1009
+ case "ThrottlingException":
1010
+ case "com.amazonaws.textract#ThrottlingException":
1011
+ throw await de_ThrottlingExceptionRes(parsedOutput);
1012
+ case "UnsupportedDocumentException":
1013
+ case "com.amazonaws.textract#UnsupportedDocumentException":
1014
+ throw await de_UnsupportedDocumentExceptionRes(parsedOutput);
1015
+ case "ConflictException":
1016
+ case "com.amazonaws.textract#ConflictException":
1017
+ throw await de_ConflictExceptionRes(parsedOutput);
1018
+ case "IdempotentParameterMismatchException":
1019
+ case "com.amazonaws.textract#IdempotentParameterMismatchException":
1020
+ throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput);
1021
+ case "LimitExceededException":
1022
+ case "com.amazonaws.textract#LimitExceededException":
1023
+ throw await de_LimitExceededExceptionRes(parsedOutput);
1024
+ case "ServiceQuotaExceededException":
1025
+ case "com.amazonaws.textract#ServiceQuotaExceededException":
1026
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
1027
+ case "ValidationException":
1028
+ case "com.amazonaws.textract#ValidationException":
1029
+ throw await de_ValidationExceptionRes(parsedOutput);
1030
+ case "InvalidKMSKeyException":
1031
+ case "com.amazonaws.textract#InvalidKMSKeyException":
1032
+ throw await de_InvalidKMSKeyExceptionRes(parsedOutput);
1033
+ case "ResourceNotFoundException":
1034
+ case "com.amazonaws.textract#ResourceNotFoundException":
1035
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
1036
+ case "InvalidJobIdException":
1037
+ case "com.amazonaws.textract#InvalidJobIdException":
1038
+ throw await de_InvalidJobIdExceptionRes(parsedOutput);
1039
+ default:
1040
+ const parsedBody = parsedOutput.body;
1041
+ return throwDefaultError({
1042
+ output,
1043
+ parsedBody,
1044
+ errorCode,
1045
+ });
1046
+ }
1047
+ };
1048
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
1049
+ const body = parsedOutput.body;
1050
+ const deserialized = smithyClient._json(body);
1051
+ const exception = new AccessDeniedException({
1052
+ $metadata: deserializeMetadata(parsedOutput),
1053
+ ...deserialized,
1054
+ });
1055
+ return smithyClient.decorateServiceException(exception, body);
1056
+ };
1057
+ const de_BadDocumentExceptionRes = async (parsedOutput, context) => {
1058
+ const body = parsedOutput.body;
1059
+ const deserialized = smithyClient._json(body);
1060
+ const exception = new BadDocumentException({
1061
+ $metadata: deserializeMetadata(parsedOutput),
1062
+ ...deserialized,
1063
+ });
1064
+ return smithyClient.decorateServiceException(exception, body);
1065
+ };
1066
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
1067
+ const body = parsedOutput.body;
1068
+ const deserialized = smithyClient._json(body);
1069
+ const exception = new ConflictException({
1070
+ $metadata: deserializeMetadata(parsedOutput),
1071
+ ...deserialized,
1072
+ });
1073
+ return smithyClient.decorateServiceException(exception, body);
1074
+ };
1075
+ const de_DocumentTooLargeExceptionRes = async (parsedOutput, context) => {
1076
+ const body = parsedOutput.body;
1077
+ const deserialized = smithyClient._json(body);
1078
+ const exception = new DocumentTooLargeException({
1079
+ $metadata: deserializeMetadata(parsedOutput),
1080
+ ...deserialized,
1081
+ });
1082
+ return smithyClient.decorateServiceException(exception, body);
1083
+ };
1084
+ const de_HumanLoopQuotaExceededExceptionRes = async (parsedOutput, context) => {
1085
+ const body = parsedOutput.body;
1086
+ const deserialized = smithyClient._json(body);
1087
+ const exception = new HumanLoopQuotaExceededException({
1088
+ $metadata: deserializeMetadata(parsedOutput),
1089
+ ...deserialized,
1090
+ });
1091
+ return smithyClient.decorateServiceException(exception, body);
1092
+ };
1093
+ const de_IdempotentParameterMismatchExceptionRes = async (parsedOutput, context) => {
1094
+ const body = parsedOutput.body;
1095
+ const deserialized = smithyClient._json(body);
1096
+ const exception = new IdempotentParameterMismatchException({
1097
+ $metadata: deserializeMetadata(parsedOutput),
1098
+ ...deserialized,
1099
+ });
1100
+ return smithyClient.decorateServiceException(exception, body);
1101
+ };
1102
+ const de_InternalServerErrorRes = async (parsedOutput, context) => {
1103
+ const body = parsedOutput.body;
1104
+ const deserialized = smithyClient._json(body);
1105
+ const exception = new InternalServerError({
1106
+ $metadata: deserializeMetadata(parsedOutput),
1107
+ ...deserialized,
1108
+ });
1109
+ return smithyClient.decorateServiceException(exception, body);
1110
+ };
1111
+ const de_InvalidJobIdExceptionRes = async (parsedOutput, context) => {
1112
+ const body = parsedOutput.body;
1113
+ const deserialized = smithyClient._json(body);
1114
+ const exception = new InvalidJobIdException({
1115
+ $metadata: deserializeMetadata(parsedOutput),
1116
+ ...deserialized,
1117
+ });
1118
+ return smithyClient.decorateServiceException(exception, body);
1119
+ };
1120
+ const de_InvalidKMSKeyExceptionRes = async (parsedOutput, context) => {
1121
+ const body = parsedOutput.body;
1122
+ const deserialized = smithyClient._json(body);
1123
+ const exception = new InvalidKMSKeyException({
1124
+ $metadata: deserializeMetadata(parsedOutput),
1125
+ ...deserialized,
1126
+ });
1127
+ return smithyClient.decorateServiceException(exception, body);
1128
+ };
1129
+ const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
1130
+ const body = parsedOutput.body;
1131
+ const deserialized = smithyClient._json(body);
1132
+ const exception = new InvalidParameterException({
1133
+ $metadata: deserializeMetadata(parsedOutput),
1134
+ ...deserialized,
1135
+ });
1136
+ return smithyClient.decorateServiceException(exception, body);
1137
+ };
1138
+ const de_InvalidS3ObjectExceptionRes = async (parsedOutput, context) => {
1139
+ const body = parsedOutput.body;
1140
+ const deserialized = smithyClient._json(body);
1141
+ const exception = new InvalidS3ObjectException({
1142
+ $metadata: deserializeMetadata(parsedOutput),
1143
+ ...deserialized,
1144
+ });
1145
+ return smithyClient.decorateServiceException(exception, body);
1146
+ };
1147
+ const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
1148
+ const body = parsedOutput.body;
1149
+ const deserialized = smithyClient._json(body);
1150
+ const exception = new LimitExceededException({
1151
+ $metadata: deserializeMetadata(parsedOutput),
1152
+ ...deserialized,
1153
+ });
1154
+ return smithyClient.decorateServiceException(exception, body);
1155
+ };
1156
+ const de_ProvisionedThroughputExceededExceptionRes = async (parsedOutput, context) => {
1157
+ const body = parsedOutput.body;
1158
+ const deserialized = smithyClient._json(body);
1159
+ const exception = new ProvisionedThroughputExceededException({
1160
+ $metadata: deserializeMetadata(parsedOutput),
1161
+ ...deserialized,
1162
+ });
1163
+ return smithyClient.decorateServiceException(exception, body);
1164
+ };
1165
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
1166
+ const body = parsedOutput.body;
1167
+ const deserialized = smithyClient._json(body);
1168
+ const exception = new ResourceNotFoundException({
1169
+ $metadata: deserializeMetadata(parsedOutput),
1170
+ ...deserialized,
1171
+ });
1172
+ return smithyClient.decorateServiceException(exception, body);
1173
+ };
1174
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
1175
+ const body = parsedOutput.body;
1176
+ const deserialized = smithyClient._json(body);
1177
+ const exception = new ServiceQuotaExceededException({
1178
+ $metadata: deserializeMetadata(parsedOutput),
1179
+ ...deserialized,
1180
+ });
1181
+ return smithyClient.decorateServiceException(exception, body);
1182
+ };
1183
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
1184
+ const body = parsedOutput.body;
1185
+ const deserialized = smithyClient._json(body);
1186
+ const exception = new ThrottlingException({
1187
+ $metadata: deserializeMetadata(parsedOutput),
1188
+ ...deserialized,
1189
+ });
1190
+ return smithyClient.decorateServiceException(exception, body);
1191
+ };
1192
+ const de_UnsupportedDocumentExceptionRes = async (parsedOutput, context) => {
1193
+ const body = parsedOutput.body;
1194
+ const deserialized = smithyClient._json(body);
1195
+ const exception = new UnsupportedDocumentException({
1196
+ $metadata: deserializeMetadata(parsedOutput),
1197
+ ...deserialized,
1198
+ });
1199
+ return smithyClient.decorateServiceException(exception, body);
1200
+ };
1201
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
1202
+ const body = parsedOutput.body;
1203
+ const deserialized = smithyClient._json(body);
1204
+ const exception = new ValidationException({
1205
+ $metadata: deserializeMetadata(parsedOutput),
1206
+ ...deserialized,
1207
+ });
1208
+ return smithyClient.decorateServiceException(exception, body);
1209
+ };
1210
+ const se_AnalyzeDocumentRequest = (input, context) => {
1211
+ return smithyClient.take(input, {
1212
+ AdaptersConfig: smithyClient._json,
1213
+ Document: (_) => se_Document(_, context),
1214
+ FeatureTypes: smithyClient._json,
1215
+ HumanLoopConfig: smithyClient._json,
1216
+ QueriesConfig: smithyClient._json,
1217
+ });
1218
+ };
1219
+ const se_AnalyzeExpenseRequest = (input, context) => {
1220
+ return smithyClient.take(input, {
1221
+ Document: (_) => se_Document(_, context),
1222
+ });
1223
+ };
1224
+ const se_AnalyzeIDRequest = (input, context) => {
1225
+ return smithyClient.take(input, {
1226
+ DocumentPages: (_) => se_DocumentPages(_, context),
1227
+ });
1228
+ };
1229
+ const se_CreateAdapterRequest = (input, context) => {
1230
+ return smithyClient.take(input, {
1231
+ AdapterName: [],
1232
+ AutoUpdate: [],
1233
+ ClientRequestToken: [true, (_) => _ ?? uuid.v4()],
1234
+ Description: [],
1235
+ FeatureTypes: smithyClient._json,
1236
+ Tags: smithyClient._json,
1237
+ });
1238
+ };
1239
+ const se_CreateAdapterVersionRequest = (input, context) => {
1240
+ return smithyClient.take(input, {
1241
+ AdapterId: [],
1242
+ ClientRequestToken: [true, (_) => _ ?? uuid.v4()],
1243
+ DatasetConfig: smithyClient._json,
1244
+ KMSKeyId: [],
1245
+ OutputConfig: smithyClient._json,
1246
+ Tags: smithyClient._json,
1247
+ });
1248
+ };
1249
+ const se_DetectDocumentTextRequest = (input, context) => {
1250
+ return smithyClient.take(input, {
1251
+ Document: (_) => se_Document(_, context),
1252
+ });
1253
+ };
1254
+ const se_Document = (input, context) => {
1255
+ return smithyClient.take(input, {
1256
+ Bytes: context.base64Encoder,
1257
+ S3Object: smithyClient._json,
1258
+ });
1259
+ };
1260
+ const se_DocumentPages = (input, context) => {
1261
+ return input
1262
+ .filter((e) => e != null)
1263
+ .map((entry) => {
1264
+ return se_Document(entry, context);
1265
+ });
1266
+ };
1267
+ const se_ListAdaptersRequest = (input, context) => {
1268
+ return smithyClient.take(input, {
1269
+ AfterCreationTime: (_) => _.getTime() / 1_000,
1270
+ BeforeCreationTime: (_) => _.getTime() / 1_000,
1271
+ MaxResults: [],
1272
+ NextToken: [],
1273
+ });
1274
+ };
1275
+ const se_ListAdapterVersionsRequest = (input, context) => {
1276
+ return smithyClient.take(input, {
1277
+ AdapterId: [],
1278
+ AfterCreationTime: (_) => _.getTime() / 1_000,
1279
+ BeforeCreationTime: (_) => _.getTime() / 1_000,
1280
+ MaxResults: [],
1281
+ NextToken: [],
1282
+ });
1283
+ };
1284
+ const de_AdapterList = (output, context) => {
1285
+ const retVal = (output || [])
1286
+ .filter((e) => e != null)
1287
+ .map((entry) => {
1288
+ return de_AdapterOverview(entry);
1289
+ });
1290
+ return retVal;
1291
+ };
1292
+ const de_AdapterOverview = (output, context) => {
1293
+ return smithyClient.take(output, {
1294
+ AdapterId: smithyClient.expectString,
1295
+ AdapterName: smithyClient.expectString,
1296
+ CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1297
+ FeatureTypes: smithyClient._json,
1298
+ });
1299
+ };
1300
+ const de_AdapterVersionEvaluationMetric = (output, context) => {
1301
+ return smithyClient.take(output, {
1302
+ AdapterVersion: (_) => de_EvaluationMetric(_),
1303
+ Baseline: (_) => de_EvaluationMetric(_),
1304
+ FeatureType: smithyClient.expectString,
1305
+ });
1306
+ };
1307
+ const de_AdapterVersionEvaluationMetrics = (output, context) => {
1308
+ const retVal = (output || [])
1309
+ .filter((e) => e != null)
1310
+ .map((entry) => {
1311
+ return de_AdapterVersionEvaluationMetric(entry);
1312
+ });
1313
+ return retVal;
1314
+ };
1315
+ const de_AdapterVersionList = (output, context) => {
1316
+ const retVal = (output || [])
1317
+ .filter((e) => e != null)
1318
+ .map((entry) => {
1319
+ return de_AdapterVersionOverview(entry);
1320
+ });
1321
+ return retVal;
1322
+ };
1323
+ const de_AdapterVersionOverview = (output, context) => {
1324
+ return smithyClient.take(output, {
1325
+ AdapterId: smithyClient.expectString,
1326
+ AdapterVersion: smithyClient.expectString,
1327
+ CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1328
+ FeatureTypes: smithyClient._json,
1329
+ Status: smithyClient.expectString,
1330
+ StatusMessage: smithyClient.expectString,
1331
+ });
1332
+ };
1333
+ const de_AnalyzeDocumentResponse = (output, context) => {
1334
+ return smithyClient.take(output, {
1335
+ AnalyzeDocumentModelVersion: smithyClient.expectString,
1336
+ Blocks: (_) => de_BlockList(_),
1337
+ DocumentMetadata: smithyClient._json,
1338
+ HumanLoopActivationOutput: (_) => de_HumanLoopActivationOutput(_),
1339
+ });
1340
+ };
1341
+ const de_AnalyzeExpenseResponse = (output, context) => {
1342
+ return smithyClient.take(output, {
1343
+ DocumentMetadata: smithyClient._json,
1344
+ ExpenseDocuments: (_) => de_ExpenseDocumentList(_),
1345
+ });
1346
+ };
1347
+ const de_AnalyzeIDDetections = (output, context) => {
1348
+ return smithyClient.take(output, {
1349
+ Confidence: smithyClient.limitedParseFloat32,
1350
+ NormalizedValue: smithyClient._json,
1351
+ Text: smithyClient.expectString,
1352
+ });
1353
+ };
1354
+ const de_AnalyzeIDResponse = (output, context) => {
1355
+ return smithyClient.take(output, {
1356
+ AnalyzeIDModelVersion: smithyClient.expectString,
1357
+ DocumentMetadata: smithyClient._json,
1358
+ IdentityDocuments: (_) => de_IdentityDocumentList(_),
1359
+ });
1360
+ };
1361
+ const de_Block = (output, context) => {
1362
+ return smithyClient.take(output, {
1363
+ BlockType: smithyClient.expectString,
1364
+ ColumnIndex: smithyClient.expectInt32,
1365
+ ColumnSpan: smithyClient.expectInt32,
1366
+ Confidence: smithyClient.limitedParseFloat32,
1367
+ EntityTypes: smithyClient._json,
1368
+ Geometry: (_) => de_Geometry(_),
1369
+ Id: smithyClient.expectString,
1370
+ Page: smithyClient.expectInt32,
1371
+ Query: smithyClient._json,
1372
+ Relationships: smithyClient._json,
1373
+ RowIndex: smithyClient.expectInt32,
1374
+ RowSpan: smithyClient.expectInt32,
1375
+ SelectionStatus: smithyClient.expectString,
1376
+ Text: smithyClient.expectString,
1377
+ TextType: smithyClient.expectString,
1378
+ });
1379
+ };
1380
+ const de_BlockList = (output, context) => {
1381
+ const retVal = (output || [])
1382
+ .filter((e) => e != null)
1383
+ .map((entry) => {
1384
+ return de_Block(entry);
1385
+ });
1386
+ return retVal;
1387
+ };
1388
+ const de_BoundingBox = (output, context) => {
1389
+ return smithyClient.take(output, {
1390
+ Height: smithyClient.limitedParseFloat32,
1391
+ Left: smithyClient.limitedParseFloat32,
1392
+ Top: smithyClient.limitedParseFloat32,
1393
+ Width: smithyClient.limitedParseFloat32,
1394
+ });
1395
+ };
1396
+ const de_DetectDocumentTextResponse = (output, context) => {
1397
+ return smithyClient.take(output, {
1398
+ Blocks: (_) => de_BlockList(_),
1399
+ DetectDocumentTextModelVersion: smithyClient.expectString,
1400
+ DocumentMetadata: smithyClient._json,
1401
+ });
1402
+ };
1403
+ const de_EvaluationMetric = (output, context) => {
1404
+ return smithyClient.take(output, {
1405
+ F1Score: smithyClient.limitedParseFloat32,
1406
+ Precision: smithyClient.limitedParseFloat32,
1407
+ Recall: smithyClient.limitedParseFloat32,
1408
+ });
1409
+ };
1410
+ const de_ExpenseCurrency = (output, context) => {
1411
+ return smithyClient.take(output, {
1412
+ Code: smithyClient.expectString,
1413
+ Confidence: smithyClient.limitedParseFloat32,
1414
+ });
1415
+ };
1416
+ const de_ExpenseDetection = (output, context) => {
1417
+ return smithyClient.take(output, {
1418
+ Confidence: smithyClient.limitedParseFloat32,
1419
+ Geometry: (_) => de_Geometry(_),
1420
+ Text: smithyClient.expectString,
1421
+ });
1422
+ };
1423
+ const de_ExpenseDocument = (output, context) => {
1424
+ return smithyClient.take(output, {
1425
+ Blocks: (_) => de_BlockList(_),
1426
+ ExpenseIndex: smithyClient.expectInt32,
1427
+ LineItemGroups: (_) => de_LineItemGroupList(_),
1428
+ SummaryFields: (_) => de_ExpenseFieldList(_),
1429
+ });
1430
+ };
1431
+ const de_ExpenseDocumentList = (output, context) => {
1432
+ const retVal = (output || [])
1433
+ .filter((e) => e != null)
1434
+ .map((entry) => {
1435
+ return de_ExpenseDocument(entry);
1436
+ });
1437
+ return retVal;
1438
+ };
1439
+ const de_ExpenseField = (output, context) => {
1440
+ return smithyClient.take(output, {
1441
+ Currency: (_) => de_ExpenseCurrency(_),
1442
+ GroupProperties: smithyClient._json,
1443
+ LabelDetection: (_) => de_ExpenseDetection(_),
1444
+ PageNumber: smithyClient.expectInt32,
1445
+ Type: (_) => de_ExpenseType(_),
1446
+ ValueDetection: (_) => de_ExpenseDetection(_),
1447
+ });
1448
+ };
1449
+ const de_ExpenseFieldList = (output, context) => {
1450
+ const retVal = (output || [])
1451
+ .filter((e) => e != null)
1452
+ .map((entry) => {
1453
+ return de_ExpenseField(entry);
1454
+ });
1455
+ return retVal;
1456
+ };
1457
+ const de_ExpenseType = (output, context) => {
1458
+ return smithyClient.take(output, {
1459
+ Confidence: smithyClient.limitedParseFloat32,
1460
+ Text: smithyClient.expectString,
1461
+ });
1462
+ };
1463
+ const de_Extraction = (output, context) => {
1464
+ return smithyClient.take(output, {
1465
+ ExpenseDocument: (_) => de_ExpenseDocument(_),
1466
+ IdentityDocument: (_) => de_IdentityDocument(_),
1467
+ LendingDocument: (_) => de_LendingDocument(_),
1468
+ });
1469
+ };
1470
+ const de_ExtractionList = (output, context) => {
1471
+ const retVal = (output || [])
1472
+ .filter((e) => e != null)
1473
+ .map((entry) => {
1474
+ return de_Extraction(entry);
1475
+ });
1476
+ return retVal;
1477
+ };
1478
+ const de_Geometry = (output, context) => {
1479
+ return smithyClient.take(output, {
1480
+ BoundingBox: (_) => de_BoundingBox(_),
1481
+ Polygon: (_) => de_Polygon(_),
1482
+ RotationAngle: smithyClient.limitedParseFloat32,
1483
+ });
1484
+ };
1485
+ const de_GetAdapterResponse = (output, context) => {
1486
+ return smithyClient.take(output, {
1487
+ AdapterId: smithyClient.expectString,
1488
+ AdapterName: smithyClient.expectString,
1489
+ AutoUpdate: smithyClient.expectString,
1490
+ CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1491
+ Description: smithyClient.expectString,
1492
+ FeatureTypes: smithyClient._json,
1493
+ Tags: smithyClient._json,
1494
+ });
1495
+ };
1496
+ const de_GetAdapterVersionResponse = (output, context) => {
1497
+ return smithyClient.take(output, {
1498
+ AdapterId: smithyClient.expectString,
1499
+ AdapterVersion: smithyClient.expectString,
1500
+ CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1501
+ DatasetConfig: smithyClient._json,
1502
+ EvaluationMetrics: (_) => de_AdapterVersionEvaluationMetrics(_),
1503
+ FeatureTypes: smithyClient._json,
1504
+ KMSKeyId: smithyClient.expectString,
1505
+ OutputConfig: smithyClient._json,
1506
+ Status: smithyClient.expectString,
1507
+ StatusMessage: smithyClient.expectString,
1508
+ Tags: smithyClient._json,
1509
+ });
1510
+ };
1511
+ const de_GetDocumentAnalysisResponse = (output, context) => {
1512
+ return smithyClient.take(output, {
1513
+ AnalyzeDocumentModelVersion: smithyClient.expectString,
1514
+ Blocks: (_) => de_BlockList(_),
1515
+ DocumentMetadata: smithyClient._json,
1516
+ JobStatus: smithyClient.expectString,
1517
+ NextToken: smithyClient.expectString,
1518
+ StatusMessage: smithyClient.expectString,
1519
+ Warnings: smithyClient._json,
1520
+ });
1521
+ };
1522
+ const de_GetDocumentTextDetectionResponse = (output, context) => {
1523
+ return smithyClient.take(output, {
1524
+ Blocks: (_) => de_BlockList(_),
1525
+ DetectDocumentTextModelVersion: smithyClient.expectString,
1526
+ DocumentMetadata: smithyClient._json,
1527
+ JobStatus: smithyClient.expectString,
1528
+ NextToken: smithyClient.expectString,
1529
+ StatusMessage: smithyClient.expectString,
1530
+ Warnings: smithyClient._json,
1531
+ });
1532
+ };
1533
+ const de_GetExpenseAnalysisResponse = (output, context) => {
1534
+ return smithyClient.take(output, {
1535
+ AnalyzeExpenseModelVersion: smithyClient.expectString,
1536
+ DocumentMetadata: smithyClient._json,
1537
+ ExpenseDocuments: (_) => de_ExpenseDocumentList(_),
1538
+ JobStatus: smithyClient.expectString,
1539
+ NextToken: smithyClient.expectString,
1540
+ StatusMessage: smithyClient.expectString,
1541
+ Warnings: smithyClient._json,
1542
+ });
1543
+ };
1544
+ const de_GetLendingAnalysisResponse = (output, context) => {
1545
+ return smithyClient.take(output, {
1546
+ AnalyzeLendingModelVersion: smithyClient.expectString,
1547
+ DocumentMetadata: smithyClient._json,
1548
+ JobStatus: smithyClient.expectString,
1549
+ NextToken: smithyClient.expectString,
1550
+ Results: (_) => de_LendingResultList(_),
1551
+ StatusMessage: smithyClient.expectString,
1552
+ Warnings: smithyClient._json,
1553
+ });
1554
+ };
1555
+ const de_HumanLoopActivationOutput = (output, context) => {
1556
+ return smithyClient.take(output, {
1557
+ HumanLoopActivationConditionsEvaluationResults: smithyClient.LazyJsonString.from,
1558
+ HumanLoopActivationReasons: smithyClient._json,
1559
+ HumanLoopArn: smithyClient.expectString,
1560
+ });
1561
+ };
1562
+ const de_IdentityDocument = (output, context) => {
1563
+ return smithyClient.take(output, {
1564
+ Blocks: (_) => de_BlockList(_),
1565
+ DocumentIndex: smithyClient.expectInt32,
1566
+ IdentityDocumentFields: (_) => de_IdentityDocumentFieldList(_),
1567
+ });
1568
+ };
1569
+ const de_IdentityDocumentField = (output, context) => {
1570
+ return smithyClient.take(output, {
1571
+ Type: (_) => de_AnalyzeIDDetections(_),
1572
+ ValueDetection: (_) => de_AnalyzeIDDetections(_),
1573
+ });
1574
+ };
1575
+ const de_IdentityDocumentFieldList = (output, context) => {
1576
+ const retVal = (output || [])
1577
+ .filter((e) => e != null)
1578
+ .map((entry) => {
1579
+ return de_IdentityDocumentField(entry);
1580
+ });
1581
+ return retVal;
1582
+ };
1583
+ const de_IdentityDocumentList = (output, context) => {
1584
+ const retVal = (output || [])
1585
+ .filter((e) => e != null)
1586
+ .map((entry) => {
1587
+ return de_IdentityDocument(entry);
1588
+ });
1589
+ return retVal;
1590
+ };
1591
+ const de_LendingDetection = (output, context) => {
1592
+ return smithyClient.take(output, {
1593
+ Confidence: smithyClient.limitedParseFloat32,
1594
+ Geometry: (_) => de_Geometry(_),
1595
+ SelectionStatus: smithyClient.expectString,
1596
+ Text: smithyClient.expectString,
1597
+ });
1598
+ };
1599
+ const de_LendingDetectionList = (output, context) => {
1600
+ const retVal = (output || [])
1601
+ .filter((e) => e != null)
1602
+ .map((entry) => {
1603
+ return de_LendingDetection(entry);
1604
+ });
1605
+ return retVal;
1606
+ };
1607
+ const de_LendingDocument = (output, context) => {
1608
+ return smithyClient.take(output, {
1609
+ LendingFields: (_) => de_LendingFieldList(_),
1610
+ SignatureDetections: (_) => de_SignatureDetectionList(_),
1611
+ });
1612
+ };
1613
+ const de_LendingField = (output, context) => {
1614
+ return smithyClient.take(output, {
1615
+ KeyDetection: (_) => de_LendingDetection(_),
1616
+ Type: smithyClient.expectString,
1617
+ ValueDetections: (_) => de_LendingDetectionList(_),
1618
+ });
1619
+ };
1620
+ const de_LendingFieldList = (output, context) => {
1621
+ const retVal = (output || [])
1622
+ .filter((e) => e != null)
1623
+ .map((entry) => {
1624
+ return de_LendingField(entry);
1625
+ });
1626
+ return retVal;
1627
+ };
1628
+ const de_LendingResult = (output, context) => {
1629
+ return smithyClient.take(output, {
1630
+ Extractions: (_) => de_ExtractionList(_),
1631
+ Page: smithyClient.expectInt32,
1632
+ PageClassification: (_) => de_PageClassification(_),
1633
+ });
1634
+ };
1635
+ const de_LendingResultList = (output, context) => {
1636
+ const retVal = (output || [])
1637
+ .filter((e) => e != null)
1638
+ .map((entry) => {
1639
+ return de_LendingResult(entry);
1640
+ });
1641
+ return retVal;
1642
+ };
1643
+ const de_LineItemFields = (output, context) => {
1644
+ return smithyClient.take(output, {
1645
+ LineItemExpenseFields: (_) => de_ExpenseFieldList(_),
1646
+ });
1647
+ };
1648
+ const de_LineItemGroup = (output, context) => {
1649
+ return smithyClient.take(output, {
1650
+ LineItemGroupIndex: smithyClient.expectInt32,
1651
+ LineItems: (_) => de_LineItemList(_),
1652
+ });
1653
+ };
1654
+ const de_LineItemGroupList = (output, context) => {
1655
+ const retVal = (output || [])
1656
+ .filter((e) => e != null)
1657
+ .map((entry) => {
1658
+ return de_LineItemGroup(entry);
1659
+ });
1660
+ return retVal;
1661
+ };
1662
+ const de_LineItemList = (output, context) => {
1663
+ const retVal = (output || [])
1664
+ .filter((e) => e != null)
1665
+ .map((entry) => {
1666
+ return de_LineItemFields(entry);
1667
+ });
1668
+ return retVal;
1669
+ };
1670
+ const de_ListAdaptersResponse = (output, context) => {
1671
+ return smithyClient.take(output, {
1672
+ Adapters: (_) => de_AdapterList(_),
1673
+ NextToken: smithyClient.expectString,
1674
+ });
1675
+ };
1676
+ const de_ListAdapterVersionsResponse = (output, context) => {
1677
+ return smithyClient.take(output, {
1678
+ AdapterVersions: (_) => de_AdapterVersionList(_),
1679
+ NextToken: smithyClient.expectString,
1680
+ });
1681
+ };
1682
+ const de_PageClassification = (output, context) => {
1683
+ return smithyClient.take(output, {
1684
+ PageNumber: (_) => de_PredictionList(_),
1685
+ PageType: (_) => de_PredictionList(_),
1686
+ });
1687
+ };
1688
+ const de_Point = (output, context) => {
1689
+ return smithyClient.take(output, {
1690
+ X: smithyClient.limitedParseFloat32,
1691
+ Y: smithyClient.limitedParseFloat32,
1692
+ });
1693
+ };
1694
+ const de_Polygon = (output, context) => {
1695
+ const retVal = (output || [])
1696
+ .filter((e) => e != null)
1697
+ .map((entry) => {
1698
+ return de_Point(entry);
1699
+ });
1700
+ return retVal;
1701
+ };
1702
+ const de_Prediction = (output, context) => {
1703
+ return smithyClient.take(output, {
1704
+ Confidence: smithyClient.limitedParseFloat32,
1705
+ Value: smithyClient.expectString,
1706
+ });
1707
+ };
1708
+ const de_PredictionList = (output, context) => {
1709
+ const retVal = (output || [])
1710
+ .filter((e) => e != null)
1711
+ .map((entry) => {
1712
+ return de_Prediction(entry);
1713
+ });
1714
+ return retVal;
1715
+ };
1716
+ const de_SignatureDetection = (output, context) => {
1717
+ return smithyClient.take(output, {
1718
+ Confidence: smithyClient.limitedParseFloat32,
1719
+ Geometry: (_) => de_Geometry(_),
1720
+ });
1721
+ };
1722
+ const de_SignatureDetectionList = (output, context) => {
1723
+ const retVal = (output || [])
1724
+ .filter((e) => e != null)
1725
+ .map((entry) => {
1726
+ return de_SignatureDetection(entry);
1727
+ });
1728
+ return retVal;
1729
+ };
1730
+ const de_UpdateAdapterResponse = (output, context) => {
1731
+ return smithyClient.take(output, {
1732
+ AdapterId: smithyClient.expectString,
1733
+ AdapterName: smithyClient.expectString,
1734
+ AutoUpdate: smithyClient.expectString,
1735
+ CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1736
+ Description: smithyClient.expectString,
1737
+ FeatureTypes: smithyClient._json,
1738
+ });
1739
+ };
1740
+ const deserializeMetadata = (output) => ({
1741
+ httpStatusCode: output.statusCode,
1742
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1743
+ extendedRequestId: output.headers["x-amz-id-2"],
1744
+ cfId: output.headers["x-amz-cf-id"],
1745
+ });
1746
+ const throwDefaultError = smithyClient.withBaseException(TextractServiceException);
1747
+ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
1748
+ const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1749
+ const contents = {
1750
+ protocol,
1751
+ hostname,
1752
+ port,
1753
+ method: "POST",
1754
+ path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
1755
+ headers,
1756
+ };
1757
+ if (body !== undefined) {
1758
+ contents.body = body;
1759
+ }
1760
+ return new protocolHttp.HttpRequest(contents);
1761
+ };
1762
+ function sharedHeaders(operation) {
1763
+ return {
1764
+ "content-type": "application/x-amz-json-1.1",
1765
+ "x-amz-target": `Textract.${operation}`,
1766
+ };
1767
+ }
2276
1768
 
2277
- // src/commands/StartDocumentTextDetectionCommand.ts
2278
-
1769
+ class AnalyzeDocumentCommand extends smithyClient.Command
1770
+ .classBuilder()
1771
+ .ep(commonParams)
1772
+ .m(function (Command, cs, config, o) {
1773
+ return [
1774
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1775
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1776
+ ];
1777
+ })
1778
+ .s("Textract", "AnalyzeDocument", {})
1779
+ .n("TextractClient", "AnalyzeDocumentCommand")
1780
+ .f(void 0, void 0)
1781
+ .ser(se_AnalyzeDocumentCommand)
1782
+ .de(de_AnalyzeDocumentCommand)
1783
+ .build() {
1784
+ }
2279
1785
 
1786
+ class AnalyzeExpenseCommand extends smithyClient.Command
1787
+ .classBuilder()
1788
+ .ep(commonParams)
1789
+ .m(function (Command, cs, config, o) {
1790
+ return [
1791
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1792
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1793
+ ];
1794
+ })
1795
+ .s("Textract", "AnalyzeExpense", {})
1796
+ .n("TextractClient", "AnalyzeExpenseCommand")
1797
+ .f(void 0, void 0)
1798
+ .ser(se_AnalyzeExpenseCommand)
1799
+ .de(de_AnalyzeExpenseCommand)
1800
+ .build() {
1801
+ }
2280
1802
 
2281
- var StartDocumentTextDetectionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2282
- return [
2283
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2284
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2285
- ];
2286
- }).s("Textract", "StartDocumentTextDetection", {}).n("TextractClient", "StartDocumentTextDetectionCommand").f(void 0, void 0).ser(se_StartDocumentTextDetectionCommand).de(de_StartDocumentTextDetectionCommand).build() {
2287
- static {
2288
- __name(this, "StartDocumentTextDetectionCommand");
2289
- }
2290
- };
1803
+ class AnalyzeIDCommand extends smithyClient.Command
1804
+ .classBuilder()
1805
+ .ep(commonParams)
1806
+ .m(function (Command, cs, config, o) {
1807
+ return [
1808
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1809
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1810
+ ];
1811
+ })
1812
+ .s("Textract", "AnalyzeID", {})
1813
+ .n("TextractClient", "AnalyzeIDCommand")
1814
+ .f(void 0, void 0)
1815
+ .ser(se_AnalyzeIDCommand)
1816
+ .de(de_AnalyzeIDCommand)
1817
+ .build() {
1818
+ }
2291
1819
 
2292
- // src/commands/StartExpenseAnalysisCommand.ts
1820
+ class CreateAdapterCommand extends smithyClient.Command
1821
+ .classBuilder()
1822
+ .ep(commonParams)
1823
+ .m(function (Command, cs, config, o) {
1824
+ return [
1825
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1826
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1827
+ ];
1828
+ })
1829
+ .s("Textract", "CreateAdapter", {})
1830
+ .n("TextractClient", "CreateAdapterCommand")
1831
+ .f(void 0, void 0)
1832
+ .ser(se_CreateAdapterCommand)
1833
+ .de(de_CreateAdapterCommand)
1834
+ .build() {
1835
+ }
2293
1836
 
1837
+ class CreateAdapterVersionCommand extends smithyClient.Command
1838
+ .classBuilder()
1839
+ .ep(commonParams)
1840
+ .m(function (Command, cs, config, o) {
1841
+ return [
1842
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1843
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1844
+ ];
1845
+ })
1846
+ .s("Textract", "CreateAdapterVersion", {})
1847
+ .n("TextractClient", "CreateAdapterVersionCommand")
1848
+ .f(void 0, void 0)
1849
+ .ser(se_CreateAdapterVersionCommand)
1850
+ .de(de_CreateAdapterVersionCommand)
1851
+ .build() {
1852
+ }
2294
1853
 
1854
+ class DeleteAdapterCommand extends smithyClient.Command
1855
+ .classBuilder()
1856
+ .ep(commonParams)
1857
+ .m(function (Command, cs, config, o) {
1858
+ return [
1859
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1860
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1861
+ ];
1862
+ })
1863
+ .s("Textract", "DeleteAdapter", {})
1864
+ .n("TextractClient", "DeleteAdapterCommand")
1865
+ .f(void 0, void 0)
1866
+ .ser(se_DeleteAdapterCommand)
1867
+ .de(de_DeleteAdapterCommand)
1868
+ .build() {
1869
+ }
2295
1870
 
2296
- var StartExpenseAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2297
- return [
2298
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2299
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2300
- ];
2301
- }).s("Textract", "StartExpenseAnalysis", {}).n("TextractClient", "StartExpenseAnalysisCommand").f(void 0, void 0).ser(se_StartExpenseAnalysisCommand).de(de_StartExpenseAnalysisCommand).build() {
2302
- static {
2303
- __name(this, "StartExpenseAnalysisCommand");
2304
- }
2305
- };
1871
+ class DeleteAdapterVersionCommand extends smithyClient.Command
1872
+ .classBuilder()
1873
+ .ep(commonParams)
1874
+ .m(function (Command, cs, config, o) {
1875
+ return [
1876
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1877
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1878
+ ];
1879
+ })
1880
+ .s("Textract", "DeleteAdapterVersion", {})
1881
+ .n("TextractClient", "DeleteAdapterVersionCommand")
1882
+ .f(void 0, void 0)
1883
+ .ser(se_DeleteAdapterVersionCommand)
1884
+ .de(de_DeleteAdapterVersionCommand)
1885
+ .build() {
1886
+ }
2306
1887
 
2307
- // src/commands/StartLendingAnalysisCommand.ts
1888
+ class DetectDocumentTextCommand extends smithyClient.Command
1889
+ .classBuilder()
1890
+ .ep(commonParams)
1891
+ .m(function (Command, cs, config, o) {
1892
+ return [
1893
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1894
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1895
+ ];
1896
+ })
1897
+ .s("Textract", "DetectDocumentText", {})
1898
+ .n("TextractClient", "DetectDocumentTextCommand")
1899
+ .f(void 0, void 0)
1900
+ .ser(se_DetectDocumentTextCommand)
1901
+ .de(de_DetectDocumentTextCommand)
1902
+ .build() {
1903
+ }
2308
1904
 
1905
+ class GetAdapterCommand extends smithyClient.Command
1906
+ .classBuilder()
1907
+ .ep(commonParams)
1908
+ .m(function (Command, cs, config, o) {
1909
+ return [
1910
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1911
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1912
+ ];
1913
+ })
1914
+ .s("Textract", "GetAdapter", {})
1915
+ .n("TextractClient", "GetAdapterCommand")
1916
+ .f(void 0, void 0)
1917
+ .ser(se_GetAdapterCommand)
1918
+ .de(de_GetAdapterCommand)
1919
+ .build() {
1920
+ }
2309
1921
 
1922
+ class GetAdapterVersionCommand extends smithyClient.Command
1923
+ .classBuilder()
1924
+ .ep(commonParams)
1925
+ .m(function (Command, cs, config, o) {
1926
+ return [
1927
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1928
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1929
+ ];
1930
+ })
1931
+ .s("Textract", "GetAdapterVersion", {})
1932
+ .n("TextractClient", "GetAdapterVersionCommand")
1933
+ .f(void 0, void 0)
1934
+ .ser(se_GetAdapterVersionCommand)
1935
+ .de(de_GetAdapterVersionCommand)
1936
+ .build() {
1937
+ }
2310
1938
 
2311
- var StartLendingAnalysisCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2312
- return [
2313
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2314
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2315
- ];
2316
- }).s("Textract", "StartLendingAnalysis", {}).n("TextractClient", "StartLendingAnalysisCommand").f(void 0, void 0).ser(se_StartLendingAnalysisCommand).de(de_StartLendingAnalysisCommand).build() {
2317
- static {
2318
- __name(this, "StartLendingAnalysisCommand");
2319
- }
2320
- };
1939
+ class GetDocumentAnalysisCommand extends smithyClient.Command
1940
+ .classBuilder()
1941
+ .ep(commonParams)
1942
+ .m(function (Command, cs, config, o) {
1943
+ return [
1944
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1945
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1946
+ ];
1947
+ })
1948
+ .s("Textract", "GetDocumentAnalysis", {})
1949
+ .n("TextractClient", "GetDocumentAnalysisCommand")
1950
+ .f(void 0, void 0)
1951
+ .ser(se_GetDocumentAnalysisCommand)
1952
+ .de(de_GetDocumentAnalysisCommand)
1953
+ .build() {
1954
+ }
2321
1955
 
2322
- // src/commands/TagResourceCommand.ts
1956
+ class GetDocumentTextDetectionCommand extends smithyClient.Command
1957
+ .classBuilder()
1958
+ .ep(commonParams)
1959
+ .m(function (Command, cs, config, o) {
1960
+ return [
1961
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1962
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1963
+ ];
1964
+ })
1965
+ .s("Textract", "GetDocumentTextDetection", {})
1966
+ .n("TextractClient", "GetDocumentTextDetectionCommand")
1967
+ .f(void 0, void 0)
1968
+ .ser(se_GetDocumentTextDetectionCommand)
1969
+ .de(de_GetDocumentTextDetectionCommand)
1970
+ .build() {
1971
+ }
2323
1972
 
1973
+ class GetExpenseAnalysisCommand extends smithyClient.Command
1974
+ .classBuilder()
1975
+ .ep(commonParams)
1976
+ .m(function (Command, cs, config, o) {
1977
+ return [
1978
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1979
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1980
+ ];
1981
+ })
1982
+ .s("Textract", "GetExpenseAnalysis", {})
1983
+ .n("TextractClient", "GetExpenseAnalysisCommand")
1984
+ .f(void 0, void 0)
1985
+ .ser(se_GetExpenseAnalysisCommand)
1986
+ .de(de_GetExpenseAnalysisCommand)
1987
+ .build() {
1988
+ }
2324
1989
 
1990
+ class GetLendingAnalysisCommand extends smithyClient.Command
1991
+ .classBuilder()
1992
+ .ep(commonParams)
1993
+ .m(function (Command, cs, config, o) {
1994
+ return [
1995
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1996
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1997
+ ];
1998
+ })
1999
+ .s("Textract", "GetLendingAnalysis", {})
2000
+ .n("TextractClient", "GetLendingAnalysisCommand")
2001
+ .f(void 0, void 0)
2002
+ .ser(se_GetLendingAnalysisCommand)
2003
+ .de(de_GetLendingAnalysisCommand)
2004
+ .build() {
2005
+ }
2325
2006
 
2326
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2327
- return [
2328
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2329
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2330
- ];
2331
- }).s("Textract", "TagResource", {}).n("TextractClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
2332
- static {
2333
- __name(this, "TagResourceCommand");
2334
- }
2335
- };
2007
+ class GetLendingAnalysisSummaryCommand extends smithyClient.Command
2008
+ .classBuilder()
2009
+ .ep(commonParams)
2010
+ .m(function (Command, cs, config, o) {
2011
+ return [
2012
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2013
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2014
+ ];
2015
+ })
2016
+ .s("Textract", "GetLendingAnalysisSummary", {})
2017
+ .n("TextractClient", "GetLendingAnalysisSummaryCommand")
2018
+ .f(void 0, void 0)
2019
+ .ser(se_GetLendingAnalysisSummaryCommand)
2020
+ .de(de_GetLendingAnalysisSummaryCommand)
2021
+ .build() {
2022
+ }
2336
2023
 
2337
- // src/commands/UntagResourceCommand.ts
2024
+ class ListAdaptersCommand extends smithyClient.Command
2025
+ .classBuilder()
2026
+ .ep(commonParams)
2027
+ .m(function (Command, cs, config, o) {
2028
+ return [
2029
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2030
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2031
+ ];
2032
+ })
2033
+ .s("Textract", "ListAdapters", {})
2034
+ .n("TextractClient", "ListAdaptersCommand")
2035
+ .f(void 0, void 0)
2036
+ .ser(se_ListAdaptersCommand)
2037
+ .de(de_ListAdaptersCommand)
2038
+ .build() {
2039
+ }
2338
2040
 
2041
+ class ListAdapterVersionsCommand extends smithyClient.Command
2042
+ .classBuilder()
2043
+ .ep(commonParams)
2044
+ .m(function (Command, cs, config, o) {
2045
+ return [
2046
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2047
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2048
+ ];
2049
+ })
2050
+ .s("Textract", "ListAdapterVersions", {})
2051
+ .n("TextractClient", "ListAdapterVersionsCommand")
2052
+ .f(void 0, void 0)
2053
+ .ser(se_ListAdapterVersionsCommand)
2054
+ .de(de_ListAdapterVersionsCommand)
2055
+ .build() {
2056
+ }
2339
2057
 
2058
+ class ListTagsForResourceCommand extends smithyClient.Command
2059
+ .classBuilder()
2060
+ .ep(commonParams)
2061
+ .m(function (Command, cs, config, o) {
2062
+ return [
2063
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2064
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2065
+ ];
2066
+ })
2067
+ .s("Textract", "ListTagsForResource", {})
2068
+ .n("TextractClient", "ListTagsForResourceCommand")
2069
+ .f(void 0, void 0)
2070
+ .ser(se_ListTagsForResourceCommand)
2071
+ .de(de_ListTagsForResourceCommand)
2072
+ .build() {
2073
+ }
2340
2074
 
2341
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2342
- return [
2343
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2344
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2345
- ];
2346
- }).s("Textract", "UntagResource", {}).n("TextractClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
2347
- static {
2348
- __name(this, "UntagResourceCommand");
2349
- }
2350
- };
2075
+ class StartDocumentAnalysisCommand extends smithyClient.Command
2076
+ .classBuilder()
2077
+ .ep(commonParams)
2078
+ .m(function (Command, cs, config, o) {
2079
+ return [
2080
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2081
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2082
+ ];
2083
+ })
2084
+ .s("Textract", "StartDocumentAnalysis", {})
2085
+ .n("TextractClient", "StartDocumentAnalysisCommand")
2086
+ .f(void 0, void 0)
2087
+ .ser(se_StartDocumentAnalysisCommand)
2088
+ .de(de_StartDocumentAnalysisCommand)
2089
+ .build() {
2090
+ }
2351
2091
 
2352
- // src/commands/UpdateAdapterCommand.ts
2092
+ class StartDocumentTextDetectionCommand extends smithyClient.Command
2093
+ .classBuilder()
2094
+ .ep(commonParams)
2095
+ .m(function (Command, cs, config, o) {
2096
+ return [
2097
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2098
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2099
+ ];
2100
+ })
2101
+ .s("Textract", "StartDocumentTextDetection", {})
2102
+ .n("TextractClient", "StartDocumentTextDetectionCommand")
2103
+ .f(void 0, void 0)
2104
+ .ser(se_StartDocumentTextDetectionCommand)
2105
+ .de(de_StartDocumentTextDetectionCommand)
2106
+ .build() {
2107
+ }
2353
2108
 
2109
+ class StartExpenseAnalysisCommand extends smithyClient.Command
2110
+ .classBuilder()
2111
+ .ep(commonParams)
2112
+ .m(function (Command, cs, config, o) {
2113
+ return [
2114
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2115
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2116
+ ];
2117
+ })
2118
+ .s("Textract", "StartExpenseAnalysis", {})
2119
+ .n("TextractClient", "StartExpenseAnalysisCommand")
2120
+ .f(void 0, void 0)
2121
+ .ser(se_StartExpenseAnalysisCommand)
2122
+ .de(de_StartExpenseAnalysisCommand)
2123
+ .build() {
2124
+ }
2354
2125
 
2126
+ class StartLendingAnalysisCommand extends smithyClient.Command
2127
+ .classBuilder()
2128
+ .ep(commonParams)
2129
+ .m(function (Command, cs, config, o) {
2130
+ return [
2131
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2132
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2133
+ ];
2134
+ })
2135
+ .s("Textract", "StartLendingAnalysis", {})
2136
+ .n("TextractClient", "StartLendingAnalysisCommand")
2137
+ .f(void 0, void 0)
2138
+ .ser(se_StartLendingAnalysisCommand)
2139
+ .de(de_StartLendingAnalysisCommand)
2140
+ .build() {
2141
+ }
2355
2142
 
2356
- var UpdateAdapterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
2357
- return [
2358
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
2359
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
2360
- ];
2361
- }).s("Textract", "UpdateAdapter", {}).n("TextractClient", "UpdateAdapterCommand").f(void 0, void 0).ser(se_UpdateAdapterCommand).de(de_UpdateAdapterCommand).build() {
2362
- static {
2363
- __name(this, "UpdateAdapterCommand");
2364
- }
2365
- };
2143
+ class TagResourceCommand extends smithyClient.Command
2144
+ .classBuilder()
2145
+ .ep(commonParams)
2146
+ .m(function (Command, cs, config, o) {
2147
+ return [
2148
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2149
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2150
+ ];
2151
+ })
2152
+ .s("Textract", "TagResource", {})
2153
+ .n("TextractClient", "TagResourceCommand")
2154
+ .f(void 0, void 0)
2155
+ .ser(se_TagResourceCommand)
2156
+ .de(de_TagResourceCommand)
2157
+ .build() {
2158
+ }
2366
2159
 
2367
- // src/Textract.ts
2368
- var commands = {
2369
- AnalyzeDocumentCommand,
2370
- AnalyzeExpenseCommand,
2371
- AnalyzeIDCommand,
2372
- CreateAdapterCommand,
2373
- CreateAdapterVersionCommand,
2374
- DeleteAdapterCommand,
2375
- DeleteAdapterVersionCommand,
2376
- DetectDocumentTextCommand,
2377
- GetAdapterCommand,
2378
- GetAdapterVersionCommand,
2379
- GetDocumentAnalysisCommand,
2380
- GetDocumentTextDetectionCommand,
2381
- GetExpenseAnalysisCommand,
2382
- GetLendingAnalysisCommand,
2383
- GetLendingAnalysisSummaryCommand,
2384
- ListAdaptersCommand,
2385
- ListAdapterVersionsCommand,
2386
- ListTagsForResourceCommand,
2387
- StartDocumentAnalysisCommand,
2388
- StartDocumentTextDetectionCommand,
2389
- StartExpenseAnalysisCommand,
2390
- StartLendingAnalysisCommand,
2391
- TagResourceCommand,
2392
- UntagResourceCommand,
2393
- UpdateAdapterCommand
2394
- };
2395
- var Textract = class extends TextractClient {
2396
- static {
2397
- __name(this, "Textract");
2398
- }
2399
- };
2400
- (0, import_smithy_client.createAggregatedClient)(commands, Textract);
2160
+ class UntagResourceCommand extends smithyClient.Command
2161
+ .classBuilder()
2162
+ .ep(commonParams)
2163
+ .m(function (Command, cs, config, o) {
2164
+ return [
2165
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2166
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2167
+ ];
2168
+ })
2169
+ .s("Textract", "UntagResource", {})
2170
+ .n("TextractClient", "UntagResourceCommand")
2171
+ .f(void 0, void 0)
2172
+ .ser(se_UntagResourceCommand)
2173
+ .de(de_UntagResourceCommand)
2174
+ .build() {
2175
+ }
2401
2176
 
2402
- // src/pagination/ListAdapterVersionsPaginator.ts
2177
+ class UpdateAdapterCommand extends smithyClient.Command
2178
+ .classBuilder()
2179
+ .ep(commonParams)
2180
+ .m(function (Command, cs, config, o) {
2181
+ return [
2182
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
2183
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
2184
+ ];
2185
+ })
2186
+ .s("Textract", "UpdateAdapter", {})
2187
+ .n("TextractClient", "UpdateAdapterCommand")
2188
+ .f(void 0, void 0)
2189
+ .ser(se_UpdateAdapterCommand)
2190
+ .de(de_UpdateAdapterCommand)
2191
+ .build() {
2192
+ }
2403
2193
 
2404
- var paginateListAdapterVersions = (0, import_core.createPaginator)(TextractClient, ListAdapterVersionsCommand, "NextToken", "NextToken", "MaxResults");
2194
+ const commands = {
2195
+ AnalyzeDocumentCommand,
2196
+ AnalyzeExpenseCommand,
2197
+ AnalyzeIDCommand,
2198
+ CreateAdapterCommand,
2199
+ CreateAdapterVersionCommand,
2200
+ DeleteAdapterCommand,
2201
+ DeleteAdapterVersionCommand,
2202
+ DetectDocumentTextCommand,
2203
+ GetAdapterCommand,
2204
+ GetAdapterVersionCommand,
2205
+ GetDocumentAnalysisCommand,
2206
+ GetDocumentTextDetectionCommand,
2207
+ GetExpenseAnalysisCommand,
2208
+ GetLendingAnalysisCommand,
2209
+ GetLendingAnalysisSummaryCommand,
2210
+ ListAdaptersCommand,
2211
+ ListAdapterVersionsCommand,
2212
+ ListTagsForResourceCommand,
2213
+ StartDocumentAnalysisCommand,
2214
+ StartDocumentTextDetectionCommand,
2215
+ StartExpenseAnalysisCommand,
2216
+ StartLendingAnalysisCommand,
2217
+ TagResourceCommand,
2218
+ UntagResourceCommand,
2219
+ UpdateAdapterCommand,
2220
+ };
2221
+ class Textract extends TextractClient {
2222
+ }
2223
+ smithyClient.createAggregatedClient(commands, Textract);
2405
2224
 
2406
- // src/pagination/ListAdaptersPaginator.ts
2225
+ const paginateListAdapterVersions = core.createPaginator(TextractClient, ListAdapterVersionsCommand, "NextToken", "NextToken", "MaxResults");
2407
2226
 
2408
- var paginateListAdapters = (0, import_core.createPaginator)(TextractClient, ListAdaptersCommand, "NextToken", "NextToken", "MaxResults");
2409
- // Annotate the CommonJS export names for ESM import in node:
2227
+ const paginateListAdapters = core.createPaginator(TextractClient, ListAdaptersCommand, "NextToken", "NextToken", "MaxResults");
2410
2228
 
2411
- 0 && (module.exports = {
2412
- TextractServiceException,
2413
- __Client,
2414
- TextractClient,
2415
- Textract,
2416
- $Command,
2417
- AnalyzeDocumentCommand,
2418
- AnalyzeExpenseCommand,
2419
- AnalyzeIDCommand,
2420
- CreateAdapterCommand,
2421
- CreateAdapterVersionCommand,
2422
- DeleteAdapterCommand,
2423
- DeleteAdapterVersionCommand,
2424
- DetectDocumentTextCommand,
2425
- GetAdapterCommand,
2426
- GetAdapterVersionCommand,
2427
- GetDocumentAnalysisCommand,
2428
- GetDocumentTextDetectionCommand,
2429
- GetExpenseAnalysisCommand,
2430
- GetLendingAnalysisCommand,
2431
- GetLendingAnalysisSummaryCommand,
2432
- ListAdapterVersionsCommand,
2433
- ListAdaptersCommand,
2434
- ListTagsForResourceCommand,
2435
- StartDocumentAnalysisCommand,
2436
- StartDocumentTextDetectionCommand,
2437
- StartExpenseAnalysisCommand,
2438
- StartLendingAnalysisCommand,
2439
- TagResourceCommand,
2440
- UntagResourceCommand,
2441
- UpdateAdapterCommand,
2442
- paginateListAdapterVersions,
2443
- paginateListAdapters,
2444
- AccessDeniedException,
2445
- FeatureType,
2446
- AdapterVersionStatus,
2447
- ContentClassifier,
2448
- BlockType,
2449
- EntityType,
2450
- RelationshipType,
2451
- SelectionStatus,
2452
- TextType,
2453
- BadDocumentException,
2454
- DocumentTooLargeException,
2455
- HumanLoopQuotaExceededException,
2456
- InternalServerError,
2457
- InvalidParameterException,
2458
- InvalidS3ObjectException,
2459
- ProvisionedThroughputExceededException,
2460
- ThrottlingException,
2461
- UnsupportedDocumentException,
2462
- ValueType,
2463
- AutoUpdate,
2464
- ConflictException,
2465
- IdempotentParameterMismatchException,
2466
- LimitExceededException,
2467
- ServiceQuotaExceededException,
2468
- ValidationException,
2469
- InvalidKMSKeyException,
2470
- ResourceNotFoundException,
2471
- JobStatus,
2472
- InvalidJobIdException
2229
+ Object.defineProperty(exports, "$Command", {
2230
+ enumerable: true,
2231
+ get: function () { return smithyClient.Command; }
2473
2232
  });
2474
-
2233
+ Object.defineProperty(exports, "__Client", {
2234
+ enumerable: true,
2235
+ get: function () { return smithyClient.Client; }
2236
+ });
2237
+ exports.AccessDeniedException = AccessDeniedException;
2238
+ exports.AdapterVersionStatus = AdapterVersionStatus;
2239
+ exports.AnalyzeDocumentCommand = AnalyzeDocumentCommand;
2240
+ exports.AnalyzeExpenseCommand = AnalyzeExpenseCommand;
2241
+ exports.AnalyzeIDCommand = AnalyzeIDCommand;
2242
+ exports.AutoUpdate = AutoUpdate;
2243
+ exports.BadDocumentException = BadDocumentException;
2244
+ exports.BlockType = BlockType;
2245
+ exports.ConflictException = ConflictException;
2246
+ exports.ContentClassifier = ContentClassifier;
2247
+ exports.CreateAdapterCommand = CreateAdapterCommand;
2248
+ exports.CreateAdapterVersionCommand = CreateAdapterVersionCommand;
2249
+ exports.DeleteAdapterCommand = DeleteAdapterCommand;
2250
+ exports.DeleteAdapterVersionCommand = DeleteAdapterVersionCommand;
2251
+ exports.DetectDocumentTextCommand = DetectDocumentTextCommand;
2252
+ exports.DocumentTooLargeException = DocumentTooLargeException;
2253
+ exports.EntityType = EntityType;
2254
+ exports.FeatureType = FeatureType;
2255
+ exports.GetAdapterCommand = GetAdapterCommand;
2256
+ exports.GetAdapterVersionCommand = GetAdapterVersionCommand;
2257
+ exports.GetDocumentAnalysisCommand = GetDocumentAnalysisCommand;
2258
+ exports.GetDocumentTextDetectionCommand = GetDocumentTextDetectionCommand;
2259
+ exports.GetExpenseAnalysisCommand = GetExpenseAnalysisCommand;
2260
+ exports.GetLendingAnalysisCommand = GetLendingAnalysisCommand;
2261
+ exports.GetLendingAnalysisSummaryCommand = GetLendingAnalysisSummaryCommand;
2262
+ exports.HumanLoopQuotaExceededException = HumanLoopQuotaExceededException;
2263
+ exports.IdempotentParameterMismatchException = IdempotentParameterMismatchException;
2264
+ exports.InternalServerError = InternalServerError;
2265
+ exports.InvalidJobIdException = InvalidJobIdException;
2266
+ exports.InvalidKMSKeyException = InvalidKMSKeyException;
2267
+ exports.InvalidParameterException = InvalidParameterException;
2268
+ exports.InvalidS3ObjectException = InvalidS3ObjectException;
2269
+ exports.JobStatus = JobStatus;
2270
+ exports.LimitExceededException = LimitExceededException;
2271
+ exports.ListAdapterVersionsCommand = ListAdapterVersionsCommand;
2272
+ exports.ListAdaptersCommand = ListAdaptersCommand;
2273
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
2274
+ exports.ProvisionedThroughputExceededException = ProvisionedThroughputExceededException;
2275
+ exports.RelationshipType = RelationshipType;
2276
+ exports.ResourceNotFoundException = ResourceNotFoundException;
2277
+ exports.SelectionStatus = SelectionStatus;
2278
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
2279
+ exports.StartDocumentAnalysisCommand = StartDocumentAnalysisCommand;
2280
+ exports.StartDocumentTextDetectionCommand = StartDocumentTextDetectionCommand;
2281
+ exports.StartExpenseAnalysisCommand = StartExpenseAnalysisCommand;
2282
+ exports.StartLendingAnalysisCommand = StartLendingAnalysisCommand;
2283
+ exports.TagResourceCommand = TagResourceCommand;
2284
+ exports.TextType = TextType;
2285
+ exports.Textract = Textract;
2286
+ exports.TextractClient = TextractClient;
2287
+ exports.TextractServiceException = TextractServiceException;
2288
+ exports.ThrottlingException = ThrottlingException;
2289
+ exports.UnsupportedDocumentException = UnsupportedDocumentException;
2290
+ exports.UntagResourceCommand = UntagResourceCommand;
2291
+ exports.UpdateAdapterCommand = UpdateAdapterCommand;
2292
+ exports.ValidationException = ValidationException;
2293
+ exports.ValueType = ValueType;
2294
+ exports.paginateListAdapterVersions = paginateListAdapterVersions;
2295
+ exports.paginateListAdapters = paginateListAdapters;