@aws-sdk/client-textract 3.36.0 → 3.39.0

package/dist-es/endpoints.js

@@ -1,6 +1,35 @@
 import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-var regionHash = {};
+var regionHash = {
+    "fips-ca-central-1": {
+        hostname: "textract-fips.ca-central-1.amazonaws.com",
+        signingRegion: "ca-central-1",
+    },
+    "fips-us-east-1": {
+        hostname: "textract-fips.us-east-1.amazonaws.com",
+        signingRegion: "us-east-1",
+    },
+    "fips-us-east-2": {
+        hostname: "textract-fips.us-east-2.amazonaws.com",
+        signingRegion: "us-east-2",
+    },
+    "fips-us-gov-east-1": {
+        hostname: "textract-fips.us-gov-east-1.amazonaws.com",
+        signingRegion: "us-gov-east-1",
+    },
+    "fips-us-gov-west-1": {
+        hostname: "textract-fips.us-gov-west-1.amazonaws.com",
+        signingRegion: "us-gov-west-1",
+    },
+    "fips-us-west-1": {
+        hostname: "textract-fips.us-west-1.amazonaws.com",
+        signingRegion: "us-west-1",
+    },
+    "fips-us-west-2": {
+        hostname: "textract-fips.us-west-2.amazonaws.com",
+        signingRegion: "us-west-2",
+    },
+};
 var partitionHash = {
     aws: {
         regions: [
@@ -19,6 +48,11 @@ var partitionHash = {
             "eu-west-1",
             "eu-west-2",
             "eu-west-3",
+            "fips-ca-central-1",
+            "fips-us-east-1",
+            "fips-us-east-2",
+            "fips-us-west-1",
+            "fips-us-west-2",
             "me-south-1",
             "sa-east-1",
             "us-east-1",
@@ -26,22 +60,27 @@ var partitionHash = {
             "us-west-1",
             "us-west-2",
         ],
+        regionRegex: "^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$",
         hostname: "textract.{region}.amazonaws.com",
     },
     "aws-cn": {
         regions: ["cn-north-1", "cn-northwest-1"],
+        regionRegex: "^cn\\-\\w+\\-\\d+$",
         hostname: "textract.{region}.amazonaws.com.cn",
     },
     "aws-iso": {
-        regions: ["us-iso-east-1"],
+        regions: ["us-iso-east-1", "us-iso-west-1"],
+        regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
         hostname: "textract.{region}.c2s.ic.gov",
     },
     "aws-iso-b": {
         regions: ["us-isob-east-1"],
+        regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
         hostname: "textract.{region}.sc2s.sgov.gov",
     },
     "aws-us-gov": {
-        regions: ["us-gov-east-1", "us-gov-west-1"],
+        regions: ["fips-us-gov-east-1", "fips-us-gov-west-1", "us-gov-east-1", "us-gov-west-1"],
+        regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
         hostname: "textract.{region}.amazonaws.com",
     },
 };

package/dist-es/index.js

@@ -1,10 +1,4 @@
-export * from "./TextractClient";
 export * from "./Textract";
-export * from "./commands/AnalyzeDocumentCommand";
-export * from "./commands/AnalyzeExpenseCommand";
-export * from "./commands/DetectDocumentTextCommand";
-export * from "./commands/GetDocumentAnalysisCommand";
-export * from "./commands/GetDocumentTextDetectionCommand";
-export * from "./commands/StartDocumentAnalysisCommand";
-export * from "./commands/StartDocumentTextDetectionCommand";
-export * from "./models/index";
+export * from "./TextractClient";
+export * from "./commands";
+export * from "./models";

package/dist-es/models/models_0.js

@@ -211,6 +211,14 @@ export var GetDocumentTextDetectionResponse;
 (function (GetDocumentTextDetectionResponse) {
     GetDocumentTextDetectionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetDocumentTextDetectionResponse || (GetDocumentTextDetectionResponse = {}));
+export var GetExpenseAnalysisRequest;
+(function (GetExpenseAnalysisRequest) {
+    GetExpenseAnalysisRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetExpenseAnalysisRequest || (GetExpenseAnalysisRequest = {}));
+export var GetExpenseAnalysisResponse;
+(function (GetExpenseAnalysisResponse) {
+    GetExpenseAnalysisResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetExpenseAnalysisResponse || (GetExpenseAnalysisResponse = {}));
 export var IdempotentParameterMismatchException;
 (function (IdempotentParameterMismatchException) {
     IdempotentParameterMismatchException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -243,3 +251,11 @@ export var StartDocumentTextDetectionResponse;
 (function (StartDocumentTextDetectionResponse) {
     StartDocumentTextDetectionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(StartDocumentTextDetectionResponse || (StartDocumentTextDetectionResponse = {}));
+export var StartExpenseAnalysisRequest;
+(function (StartExpenseAnalysisRequest) {
+    StartExpenseAnalysisRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartExpenseAnalysisRequest || (StartExpenseAnalysisRequest = {}));
+export var StartExpenseAnalysisResponse;
+(function (StartExpenseAnalysisResponse) {
+    StartExpenseAnalysisResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(StartExpenseAnalysisResponse || (StartExpenseAnalysisResponse = {}));

package/dist-es/protocols/Aws_json1_1.js

@@ -56,6 +56,17 @@ export var serializeAws_json1_1GetDocumentTextDetectionCommand = function (input
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_json1_1GetExpenseAnalysisCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.1",
+            "x-amz-target": "Textract.GetExpenseAnalysis",
+        };
+        body = JSON.stringify(serializeAws_json1_1GetExpenseAnalysisRequest(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_json1_1StartDocumentAnalysisCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -78,6 +89,17 @@ export var serializeAws_json1_1StartDocumentTextDetectionCommand = function (inp
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_json1_1StartExpenseAnalysisCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.1",
+            "x-amz-target": "Textract.StartExpenseAnalysis",
+        };
+        body = JSON.stringify(serializeAws_json1_1StartExpenseAnalysisRequest(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var deserializeAws_json1_1AnalyzeDocumentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -670,6 +692,118 @@ var deserializeAws_json1_1GetDocumentTextDetectionCommandError = function (outpu
         }
     });
 }); };
+export var deserializeAws_json1_1GetExpenseAnalysisCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_1GetExpenseAnalysisCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_1GetExpenseAnalysisResponse(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_1GetExpenseAnalysisCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, _j, _k, parsedBody, message;
+    var _l;
+    return __generator(this, function (_m) {
+        switch (_m.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _l = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_l.body = _m.sent(), _l)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.textract#AccessDeniedException": return [3, 2];
+                    case "InternalServerError": return [3, 4];
+                    case "com.amazonaws.textract#InternalServerError": return [3, 4];
+                    case "InvalidJobIdException": return [3, 6];
+                    case "com.amazonaws.textract#InvalidJobIdException": return [3, 6];
+                    case "InvalidKMSKeyException": return [3, 8];
+                    case "com.amazonaws.textract#InvalidKMSKeyException": return [3, 8];
+                    case "InvalidParameterException": return [3, 10];
+                    case "com.amazonaws.textract#InvalidParameterException": return [3, 10];
+                    case "InvalidS3ObjectException": return [3, 12];
+                    case "com.amazonaws.textract#InvalidS3ObjectException": return [3, 12];
+                    case "ProvisionedThroughputExceededException": return [3, 14];
+                    case "com.amazonaws.textract#ProvisionedThroughputExceededException": return [3, 14];
+                    case "ThrottlingException": return [3, 16];
+                    case "com.amazonaws.textract#ThrottlingException": return [3, 16];
+                }
+                return [3, 18];
+            case 2:
+                _c = [{}];
+                return [4, deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 4:
+                _d = [{}];
+                return [4, deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)];
+            case 5:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 6:
+                _e = [{}];
+                return [4, deserializeAws_json1_1InvalidJobIdExceptionResponse(parsedOutput, context)];
+            case 7:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 8:
+                _f = [{}];
+                return [4, deserializeAws_json1_1InvalidKMSKeyExceptionResponse(parsedOutput, context)];
+            case 9:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 10:
+                _g = [{}];
+                return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
+            case 11:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 12:
+                _h = [{}];
+                return [4, deserializeAws_json1_1InvalidS3ObjectExceptionResponse(parsedOutput, context)];
+            case 13:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 14:
+                _j = [{}];
+                return [4, deserializeAws_json1_1ProvisionedThroughputExceededExceptionResponse(parsedOutput, context)];
+            case 15:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _j.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 16:
+                _k = [{}];
+                return [4, deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context)];
+            case 17:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _k.concat([(_m.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 19];
+            case 18:
+                parsedBody = parsedOutput.body;
+                errorCode = parsedBody.code || parsedBody.Code || errorCode;
+                response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
+                _m.label = 19;
+            case 19:
+                message = response.message || response.Message || errorCode;
+                response.message = message;
+                delete response.Message;
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
+        }
+    });
+}); };
 export var deserializeAws_json1_1StartDocumentAnalysisCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -958,6 +1092,150 @@ var deserializeAws_json1_1StartDocumentTextDetectionCommandError = function (out
         }
     });
 }); };
+export var deserializeAws_json1_1StartExpenseAnalysisCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_1StartExpenseAnalysisCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_1StartExpenseAnalysisResponse(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_1StartExpenseAnalysisCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, parsedBody, message;
+    var _q;
+    return __generator(this, function (_r) {
+        switch (_r.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _q = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_q.body = _r.sent(), _q)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.textract#AccessDeniedException": return [3, 2];
+                    case "BadDocumentException": return [3, 4];
+                    case "com.amazonaws.textract#BadDocumentException": return [3, 4];
+                    case "DocumentTooLargeException": return [3, 6];
+                    case "com.amazonaws.textract#DocumentTooLargeException": return [3, 6];
+                    case "IdempotentParameterMismatchException": return [3, 8];
+                    case "com.amazonaws.textract#IdempotentParameterMismatchException": return [3, 8];
+                    case "InternalServerError": return [3, 10];
+                    case "com.amazonaws.textract#InternalServerError": return [3, 10];
+                    case "InvalidKMSKeyException": return [3, 12];
+                    case "com.amazonaws.textract#InvalidKMSKeyException": return [3, 12];
+                    case "InvalidParameterException": return [3, 14];
+                    case "com.amazonaws.textract#InvalidParameterException": return [3, 14];
+                    case "InvalidS3ObjectException": return [3, 16];
+                    case "com.amazonaws.textract#InvalidS3ObjectException": return [3, 16];
+                    case "LimitExceededException": return [3, 18];
+                    case "com.amazonaws.textract#LimitExceededException": return [3, 18];
+                    case "ProvisionedThroughputExceededException": return [3, 20];
+                    case "com.amazonaws.textract#ProvisionedThroughputExceededException": return [3, 20];
+                    case "ThrottlingException": return [3, 22];
+                    case "com.amazonaws.textract#ThrottlingException": return [3, 22];
+                    case "UnsupportedDocumentException": return [3, 24];
+                    case "com.amazonaws.textract#UnsupportedDocumentException": return [3, 24];
+                }
+                return [3, 26];
+            case 2:
+                _c = [{}];
+                return [4, deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 4:
+                _d = [{}];
+                return [4, deserializeAws_json1_1BadDocumentExceptionResponse(parsedOutput, context)];
+            case 5:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 6:
+                _e = [{}];
+                return [4, deserializeAws_json1_1DocumentTooLargeExceptionResponse(parsedOutput, context)];
+            case 7:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 8:
+                _f = [{}];
+                return [4, deserializeAws_json1_1IdempotentParameterMismatchExceptionResponse(parsedOutput, context)];
+            case 9:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 10:
+                _g = [{}];
+                return [4, deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)];
+            case 11:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 12:
+                _h = [{}];
+                return [4, deserializeAws_json1_1InvalidKMSKeyExceptionResponse(parsedOutput, context)];
+            case 13:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 14:
+                _j = [{}];
+                return [4, deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)];
+            case 15:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _j.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 16:
+                _k = [{}];
+                return [4, deserializeAws_json1_1InvalidS3ObjectExceptionResponse(parsedOutput, context)];
+            case 17:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _k.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 18:
+                _l = [{}];
+                return [4, deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)];
+            case 19:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _l.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 20:
+                _m = [{}];
+                return [4, deserializeAws_json1_1ProvisionedThroughputExceededExceptionResponse(parsedOutput, context)];
+            case 21:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _m.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 22:
+                _o = [{}];
+                return [4, deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context)];
+            case 23:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _o.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 24:
+                _p = [{}];
+                return [4, deserializeAws_json1_1UnsupportedDocumentExceptionResponse(parsedOutput, context)];
+            case 25:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _p.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 27];
+            case 26:
+                parsedBody = parsedOutput.body;
+                errorCode = parsedBody.code || parsedBody.Code || errorCode;
+                response = __assign(__assign({}, parsedBody), { name: "" + errorCode, message: parsedBody.message || parsedBody.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
+                _r.label = 27;
+            case 27:
+                message = response.message || response.Message || errorCode;
+                response.message = message;
+                delete response.Message;
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
+        }
+    });
+}); };
 var deserializeAws_json1_1AccessDeniedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var body, deserialized, contents;
     return __generator(this, function (_a) {
@@ -1134,6 +1412,9 @@ var serializeAws_json1_1GetDocumentAnalysisRequest = function (input, context) {
 var serializeAws_json1_1GetDocumentTextDetectionRequest = function (input, context) {
     return __assign(__assign(__assign({}, (input.JobId !== undefined && input.JobId !== null && { JobId: input.JobId })), (input.MaxResults !== undefined && input.MaxResults !== null && { MaxResults: input.MaxResults })), (input.NextToken !== undefined && input.NextToken !== null && { NextToken: input.NextToken }));
 };
+var serializeAws_json1_1GetExpenseAnalysisRequest = function (input, context) {
+    return __assign(__assign(__assign({}, (input.JobId !== undefined && input.JobId !== null && { JobId: input.JobId })), (input.MaxResults !== undefined && input.MaxResults !== null && { MaxResults: input.MaxResults })), (input.NextToken !== undefined && input.NextToken !== null && { NextToken: input.NextToken }));
+};
 var serializeAws_json1_1HumanLoopConfig = function (input, context) {
     return __assign(__assign(__assign({}, (input.DataAttributes !== undefined &&
         input.DataAttributes !== null && {
@@ -1179,6 +1460,17 @@ var serializeAws_json1_1StartDocumentTextDetectionRequest = function (input, con
     })), (input.OutputConfig !== undefined &&
         input.OutputConfig !== null && { OutputConfig: serializeAws_json1_1OutputConfig(input.OutputConfig, context) }));
 };
+var serializeAws_json1_1StartExpenseAnalysisRequest = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.ClientRequestToken !== undefined &&
+        input.ClientRequestToken !== null && { ClientRequestToken: input.ClientRequestToken })), (input.DocumentLocation !== undefined &&
+        input.DocumentLocation !== null && {
+        DocumentLocation: serializeAws_json1_1DocumentLocation(input.DocumentLocation, context),
+    })), (input.JobTag !== undefined && input.JobTag !== null && { JobTag: input.JobTag })), (input.KMSKeyId !== undefined && input.KMSKeyId !== null && { KMSKeyId: input.KMSKeyId })), (input.NotificationChannel !== undefined &&
+        input.NotificationChannel !== null && {
+        NotificationChannel: serializeAws_json1_1NotificationChannel(input.NotificationChannel, context),
+    })), (input.OutputConfig !== undefined &&
+        input.OutputConfig !== null && { OutputConfig: serializeAws_json1_1OutputConfig(input.OutputConfig, context) }));
+};
 var deserializeAws_json1_1AccessDeniedException = function (output, context) {
     return {
         Code: __expectString(output.Code),
@@ -1393,6 +1685,23 @@ var deserializeAws_json1_1GetDocumentTextDetectionResponse = function (output, c
             : undefined,
     };
 };
+var deserializeAws_json1_1GetExpenseAnalysisResponse = function (output, context) {
+    return {
+        AnalyzeExpenseModelVersion: __expectString(output.AnalyzeExpenseModelVersion),
+        DocumentMetadata: output.DocumentMetadata !== undefined && output.DocumentMetadata !== null
+            ? deserializeAws_json1_1DocumentMetadata(output.DocumentMetadata, context)
+            : undefined,
+        ExpenseDocuments: output.ExpenseDocuments !== undefined && output.ExpenseDocuments !== null
+            ? deserializeAws_json1_1ExpenseDocumentList(output.ExpenseDocuments, context)
+            : undefined,
+        JobStatus: __expectString(output.JobStatus),
+        NextToken: __expectString(output.NextToken),
+        StatusMessage: __expectString(output.StatusMessage),
+        Warnings: output.Warnings !== undefined && output.Warnings !== null
+            ? deserializeAws_json1_1Warnings(output.Warnings, context)
+            : undefined,
+    };
+};
 var deserializeAws_json1_1HumanLoopActivationOutput = function (output, context) {
     return {
         HumanLoopActivationConditionsEvaluationResults: output.HumanLoopActivationConditionsEvaluationResults !== undefined &&
@@ -1569,6 +1878,11 @@ var deserializeAws_json1_1StartDocumentTextDetectionResponse = function (output,
         JobId: __expectString(output.JobId),
     };
 };
+var deserializeAws_json1_1StartExpenseAnalysisResponse = function (output, context) {
+    return {
+        JobId: __expectString(output.JobId),
+    };
+};
 var deserializeAws_json1_1ThrottlingException = function (output, context) {
     return {
         Code: __expectString(output.Code),

package/dist-types/Textract.d.ts

@@ -4,8 +4,10 @@ import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./comma
 import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "./commands/DetectDocumentTextCommand";
 import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } from "./commands/GetDocumentAnalysisCommand";
 import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "./commands/GetDocumentTextDetectionCommand";
+import { GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput } from "./commands/GetExpenseAnalysisCommand";
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "./commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "./commands/StartDocumentTextDetectionCommand";
+import { StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput } from "./commands/StartExpenseAnalysisCommand";
 import { TextractClient } from "./TextractClient";
 /**
  * <p>Amazon Textract detects and analyzes text in documents and converts it
@@ -164,12 +166,34 @@ export declare class Textract extends TextractClient {
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, options?: __HttpHandlerOptions): Promise<GetDocumentTextDetectionCommandOutput>;
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, cb: (err: any, data?: GetDocumentTextDetectionCommandOutput) => void): void;
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDocumentTextDetectionCommandOutput) => void): void;
+    /**
+     * <p>Gets the results for an Amazon Textract asynchronous operation that analyzes invoices and
+     *    receipts. Amazon Textract finds contact information, items purchased, and vendor name, from input
+     *    invoices and receipts.</p>
+     *          <p>You start asynchronous invoice/receipt analysis by calling <a>StartExpenseAnalysis</a>, which returns a job identifier (<code>JobId</code>). Upon
+     *    completion of the invoice/receipt analysis, Amazon Textract publishes the completion status to the
+     *    Amazon Simple Notification Service (Amazon SNS) topic. This topic must be registered in the initial call to
+     *     <code>StartExpenseAnalysis</code>. To get the results of the invoice/receipt analysis operation,
+     *    first ensure that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>. If so,
+     *    call <code>GetExpenseAnalysis</code>, and pass the job identifier (<code>JobId</code>) from the
+     *    initial call to <code>StartExpenseAnalysis</code>.</p>
+     *          <p>Use the MaxResults parameter to limit the number of blocks that are returned. If there are
+     *    more results than specified in <code>MaxResults</code>, the value of <code>NextToken</code> in
+     *    the operation response contains a pagination token for getting the next set of results. To get
+     *    the next page of results, call <code>GetExpenseAnalysis</code>, and populate the
+     *     <code>NextToken</code> request parameter with the token value that's returned from the previous
+     *    call to <code>GetExpenseAnalysis</code>.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/invoices-receipts.html">Analyzing Invoices and Receipts</a>.</p>
+     */
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<GetExpenseAnalysisCommandOutput>;
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, cb: (err: any, data?: GetExpenseAnalysisCommandOutput) => void): void;
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetExpenseAnalysisCommandOutput) => void): void;
     /**
      * <p>Starts the asynchronous analysis of an input document for relationships between detected
      *          items such as key-value pairs, tables, and selection elements.</p>
      *
      *          <p>
-     *             <code>StartDocumentAnalysis</code> can analyze text in documents that are in JPEG, PNG, and PDF format. The
+     *             <code>StartDocumentAnalysis</code> can analyze text in documents that are in JPEG, PNG, TIFF, and PDF format. The
      *          documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
      *          of the document.
      *          </p>
@@ -191,7 +215,7 @@ export declare class Textract extends TextractClient {
      * <p>Starts the asynchronous detection of text in a document. Amazon Textract can detect lines of
      *          text and the words that make up a line of text.</p>
      *          <p>
-     *             <code>StartDocumentTextDetection</code> can analyze text in documents that are in JPEG, PNG, and PDF format. The
+     *             <code>StartDocumentTextDetection</code> can analyze text in documents that are in JPEG, PNG, TIFF, and PDF format. The
      *         documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
      *         of the document.
      *      </p>
@@ -209,4 +233,25 @@ export declare class Textract extends TextractClient {
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, options?: __HttpHandlerOptions): Promise<StartDocumentTextDetectionCommandOutput>;
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, cb: (err: any, data?: StartDocumentTextDetectionCommandOutput) => void): void;
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartDocumentTextDetectionCommandOutput) => void): void;
+    /**
+     * <p>Starts the asynchronous analysis of invoices or receipts for data like contact information,
+     *    items purchased, and vendor names.</p>
+     *
+     *          <p>
+     *             <code>StartExpenseAnalysis</code> can analyze text in documents that are in JPEG, PNG, and
+     *    PDF format. The documents must be stored in an Amazon S3 bucket. Use the <a>DocumentLocation</a> parameter to specify the name of your S3 bucket and the name of the
+     *    document in that bucket. </p>
+     *          <p>
+     *             <code>StartExpenseAnalysis</code> returns a job identifier (<code>JobId</code>) that you
+     *    will provide to <code>GetExpenseAnalysis</code> to retrieve the results of the operation. When
+     *    the analysis of the input invoices/receipts is finished, Amazon Textract publishes a completion
+     *    status to the Amazon Simple Notification Service (Amazon SNS) topic that you provide to the <code>NotificationChannel</code>.
+     *    To obtain the results of the invoice and receipt analysis operation, ensure that the status value
+     *    published to the Amazon SNS topic is <code>SUCCEEDED</code>. If so, call <a>GetExpenseAnalysis</a>, and pass the job identifier (<code>JobId</code>) that was
+     *    returned by your call to <code>StartExpenseAnalysis</code>.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/invoice-receipts.html">Analyzing Invoices and Receipts</a>.</p>
+     */
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<StartExpenseAnalysisCommandOutput>;
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, cb: (err: any, data?: StartExpenseAnalysisCommandOutput) => void): void;
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartExpenseAnalysisCommandOutput) => void): void;
 }

package/dist-types/TextractClient.d.ts

@@ -11,10 +11,12 @@ import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./comma
 import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "./commands/DetectDocumentTextCommand";
 import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } from "./commands/GetDocumentAnalysisCommand";
 import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "./commands/GetDocumentTextDetectionCommand";
+import { GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput } from "./commands/GetExpenseAnalysisCommand";
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "./commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "./commands/StartDocumentTextDetectionCommand";
-export declare type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput;
-export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput;
+import { StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput } from "./commands/StartExpenseAnalysisCommand";
+export declare type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | GetExpenseAnalysisCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput | StartExpenseAnalysisCommandInput;
+export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | GetExpenseAnalysisCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput | StartExpenseAnalysisCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.

package/dist-types/commands/GetExpenseAnalysisCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetExpenseAnalysisRequest, GetExpenseAnalysisResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface GetExpenseAnalysisCommandInput extends GetExpenseAnalysisRequest {
+}
+export interface GetExpenseAnalysisCommandOutput extends GetExpenseAnalysisResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the results for an Amazon Textract asynchronous operation that analyzes invoices and
+ *    receipts. Amazon Textract finds contact information, items purchased, and vendor name, from input
+ *    invoices and receipts.</p>
+ *          <p>You start asynchronous invoice/receipt analysis by calling <a>StartExpenseAnalysis</a>, which returns a job identifier (<code>JobId</code>). Upon
+ *    completion of the invoice/receipt analysis, Amazon Textract publishes the completion status to the
+ *    Amazon Simple Notification Service (Amazon SNS) topic. This topic must be registered in the initial call to
+ *     <code>StartExpenseAnalysis</code>. To get the results of the invoice/receipt analysis operation,
+ *    first ensure that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>. If so,
+ *    call <code>GetExpenseAnalysis</code>, and pass the job identifier (<code>JobId</code>) from the
+ *    initial call to <code>StartExpenseAnalysis</code>.</p>
+ *          <p>Use the MaxResults parameter to limit the number of blocks that are returned. If there are
+ *    more results than specified in <code>MaxResults</code>, the value of <code>NextToken</code> in
+ *    the operation response contains a pagination token for getting the next set of results. To get
+ *    the next page of results, call <code>GetExpenseAnalysis</code>, and populate the
+ *     <code>NextToken</code> request parameter with the token value that's returned from the previous
+ *    call to <code>GetExpenseAnalysis</code>.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/invoices-receipts.html">Analyzing Invoices and Receipts</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TextractClient, GetExpenseAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
+ * // const { TextractClient, GetExpenseAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
+ * const client = new TextractClient(config);
+ * const command = new GetExpenseAnalysisCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetExpenseAnalysisCommandInput} for command's `input` shape.
+ * @see {@link GetExpenseAnalysisCommandOutput} for command's `response` shape.
+ * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetExpenseAnalysisCommand extends $Command<GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: GetExpenseAnalysisCommandInput;
+    constructor(input: GetExpenseAnalysisCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput>;
+    private serialize;
+    private deserialize;
+}