@aws-sdk/client-textract 3.35.0 → 3.36.0

package/src/commands/GetDocumentAnalysisCommand.ts

@@ -1,139 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GetDocumentAnalysisRequest, GetDocumentAnalysisResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1GetDocumentAnalysisCommand,
-  serializeAws_json1_1GetDocumentAnalysisCommand,
-} from "../protocols/Aws_json1_1";
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-
-export interface GetDocumentAnalysisCommandInput extends GetDocumentAnalysisRequest {}
-export interface GetDocumentAnalysisCommandOutput extends GetDocumentAnalysisResponse, __MetadataBearer {}
-
-/**
- * <p>Gets the results for an Amazon Textract asynchronous operation that analyzes text in a document.</p>
- *          <p>You start asynchronous text analysis by calling <a>StartDocumentAnalysis</a>, which returns a job identifier
- *             (<code>JobId</code>). When the text analysis operation finishes, Amazon Textract publishes a
- *          completion status to the Amazon Simple Notification Service (Amazon SNS) topic that's registered in the initial call to
- *             <code>StartDocumentAnalysis</code>. To get the results of the text-detection operation,
- *          first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *          If so, call <code>GetDocumentAnalysis</code>, and pass the job identifier
- *             (<code>JobId</code>) from the initial call to <code>StartDocumentAnalysis</code>.</p>
- *          <p>
- *             <code>GetDocumentAnalysis</code> returns an array of <a>Block</a> objects. The following
- *          types of information are returned: </p>
- *          <ul>
- *             <li>
- *                <p>Form data (key-value pairs). The related information is returned in two <a>Block</a> objects, each of type <code>KEY_VALUE_SET</code>: a KEY
- *             <code>Block</code> object and a VALUE <code>Block</code> object. For example,
- *             <i>Name: Ana Silva Carolina</i> contains a key and value.
- *             <i>Name:</i> is the key. <i>Ana Silva Carolina</i> is
- *             the value.</p>
- *             </li>
- *             <li>
- *                <p>Table and table cell data. A TABLE <code>Block</code> object contains information about a detected table. A CELL
- *             <code>Block</code> object is returned for each cell in a table.</p>
- *             </li>
- *             <li>
- *                <p>Lines and words of text. A LINE <code>Block</code> object contains one or more WORD <code>Block</code> objects.
- *             All lines and words that are detected in the document are returned (including text that doesn't have a
- *             relationship with the value of the <code>StartDocumentAnalysis</code>
- *                   <code>FeatureTypes</code> input parameter). </p>
- *             </li>
- *          </ul>
- *
- *          <p>Selection elements such as check boxes and option buttons (radio buttons) can be detected in form data and in tables.
- *          A SELECTION_ELEMENT <code>Block</code> object contains information about a selection element,
- *          including the selection status.</p>
- *
- *
- *
- *          <p>Use the <code>MaxResults</code> 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>GetDocumentAnalysis</code>, and populate the <code>NextToken</code> request
- *          parameter with the token value that's returned from the previous call to
- *             <code>GetDocumentAnalysis</code>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, GetDocumentAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, GetDocumentAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new GetDocumentAnalysisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDocumentAnalysisCommandInput} for command's `input` shape.
- * @see {@link GetDocumentAnalysisCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class GetDocumentAnalysisCommand extends $Command<
-  GetDocumentAnalysisCommandInput,
-  GetDocumentAnalysisCommandOutput,
-  TextractClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetDocumentAnalysisCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: TextractClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "TextractClient";
-    const commandName = "GetDocumentAnalysisCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetDocumentAnalysisRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetDocumentAnalysisResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetDocumentAnalysisCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1GetDocumentAnalysisCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetDocumentAnalysisCommandOutput> {
-    return deserializeAws_json1_1GetDocumentAnalysisCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/GetDocumentTextDetectionCommand.ts

@@ -1,119 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { GetDocumentTextDetectionRequest, GetDocumentTextDetectionResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1GetDocumentTextDetectionCommand,
-  serializeAws_json1_1GetDocumentTextDetectionCommand,
-} from "../protocols/Aws_json1_1";
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-
-export interface GetDocumentTextDetectionCommandInput extends GetDocumentTextDetectionRequest {}
-export interface GetDocumentTextDetectionCommandOutput extends GetDocumentTextDetectionResponse, __MetadataBearer {}
-
-/**
- * <p>Gets the results for an Amazon Textract asynchronous operation that detects text in a document.
- *      Amazon Textract can detect lines of text and the words that make up a line of text.</p>
- *          <p>You start asynchronous text detection by calling <a>StartDocumentTextDetection</a>, which returns a job identifier
- *             (<code>JobId</code>). When the text detection operation finishes, Amazon Textract publishes a
- *          completion status to the Amazon Simple Notification Service (Amazon SNS) topic that's registered in the initial call to
- *             <code>StartDocumentTextDetection</code>. To get the results of the text-detection
- *          operation, first check that the status value published to the Amazon SNS topic is
- *             <code>SUCCEEDED</code>. If so, call <code>GetDocumentTextDetection</code>, and pass the
- *          job identifier (<code>JobId</code>) from the initial call to
- *             <code>StartDocumentTextDetection</code>.</p>
- *          <p>
- *             <code>GetDocumentTextDetection</code> returns an array of <a>Block</a>
- *          objects. </p>
- *          <p>Each document page has as an associated <code>Block</code> of type PAGE. Each PAGE <code>Block</code> object
- *         is the parent of LINE <code>Block</code> objects that represent the lines of detected text on a page. A LINE <code>Block</code> object is
- *         a parent for each word that makes up the line. Words are represented by <code>Block</code> objects of type WORD.</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>GetDocumentTextDetection</code>, and populate the <code>NextToken</code> request
- *          parameter with the token value that's returned from the previous call to
- *             <code>GetDocumentTextDetection</code>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, GetDocumentTextDetectionCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, GetDocumentTextDetectionCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new GetDocumentTextDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDocumentTextDetectionCommandInput} for command's `input` shape.
- * @see {@link GetDocumentTextDetectionCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class GetDocumentTextDetectionCommand extends $Command<
-  GetDocumentTextDetectionCommandInput,
-  GetDocumentTextDetectionCommandOutput,
-  TextractClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetDocumentTextDetectionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: TextractClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "TextractClient";
-    const commandName = "GetDocumentTextDetectionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetDocumentTextDetectionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetDocumentTextDetectionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetDocumentTextDetectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1GetDocumentTextDetectionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetDocumentTextDetectionCommandOutput> {
-    return deserializeAws_json1_1GetDocumentTextDetectionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/StartDocumentAnalysisCommand.ts

@@ -1,112 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { StartDocumentAnalysisRequest, StartDocumentAnalysisResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1StartDocumentAnalysisCommand,
-  serializeAws_json1_1StartDocumentAnalysisCommand,
-} from "../protocols/Aws_json1_1";
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-
-export interface StartDocumentAnalysisCommandInput extends StartDocumentAnalysisRequest {}
-export interface StartDocumentAnalysisCommandOutput extends StartDocumentAnalysisResponse, __MetadataBearer {}
-
-/**
- * <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
- *          documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
- *          of the document.
- *          </p>
- *          <p>
- *             <code>StartDocumentAnalysis</code> returns a job identifier
- *             (<code>JobId</code>) that you use to get the results of the operation. When text
- *          analysis is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification Service (Amazon SNS)
- *          topic that you specify in <code>NotificationChannel</code>. To get the results of the text
- *          analysis operation, first check that the status value published to the Amazon SNS topic is
- *             <code>SUCCEEDED</code>. If so, call <a>GetDocumentAnalysis</a>, and pass
- *          the job identifier (<code>JobId</code>) from the initial call to
- *             <code>StartDocumentAnalysis</code>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, StartDocumentAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, StartDocumentAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new StartDocumentAnalysisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDocumentAnalysisCommandInput} for command's `input` shape.
- * @see {@link StartDocumentAnalysisCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class StartDocumentAnalysisCommand extends $Command<
-  StartDocumentAnalysisCommandInput,
-  StartDocumentAnalysisCommandOutput,
-  TextractClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: StartDocumentAnalysisCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: TextractClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "TextractClient";
-    const commandName = "StartDocumentAnalysisCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: StartDocumentAnalysisRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: StartDocumentAnalysisResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: StartDocumentAnalysisCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1StartDocumentAnalysisCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<StartDocumentAnalysisCommandOutput> {
-    return deserializeAws_json1_1StartDocumentAnalysisCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/StartDocumentTextDetectionCommand.ts

@@ -1,114 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { StartDocumentTextDetectionRequest, StartDocumentTextDetectionResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1StartDocumentTextDetectionCommand,
-  serializeAws_json1_1StartDocumentTextDetectionCommand,
-} from "../protocols/Aws_json1_1";
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-
-export interface StartDocumentTextDetectionCommandInput extends StartDocumentTextDetectionRequest {}
-export interface StartDocumentTextDetectionCommandOutput extends StartDocumentTextDetectionResponse, __MetadataBearer {}
-
-/**
- * <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
- *         documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
- *         of the document.
- *      </p>
- *          <p>
- *             <code>StartTextDetection</code> returns a job identifier
- *             (<code>JobId</code>) that you use to get the results of the operation. When text
- *          detection is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification Service (Amazon SNS)
- *          topic that you specify in <code>NotificationChannel</code>. To get the results of the text
- *          detection operation, first check that the status value published to the Amazon SNS topic is
- *             <code>SUCCEEDED</code>. If so, call <a>GetDocumentTextDetection</a>, and
- *          pass the job identifier (<code>JobId</code>) from the initial call to
- *             <code>StartDocumentTextDetection</code>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, StartDocumentTextDetectionCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, StartDocumentTextDetectionCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new StartDocumentTextDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDocumentTextDetectionCommandInput} for command's `input` shape.
- * @see {@link StartDocumentTextDetectionCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class StartDocumentTextDetectionCommand extends $Command<
-  StartDocumentTextDetectionCommandInput,
-  StartDocumentTextDetectionCommandOutput,
-  TextractClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: StartDocumentTextDetectionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: TextractClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "TextractClient";
-    const commandName = "StartDocumentTextDetectionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: StartDocumentTextDetectionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: StartDocumentTextDetectionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: StartDocumentTextDetectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1StartDocumentTextDetectionCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<StartDocumentTextDetectionCommandOutput> {
-    return deserializeAws_json1_1StartDocumentTextDetectionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/endpoints.ts

@@ -1,57 +0,0 @@
-import { getRegionInfo, PartitionHash, RegionHash } from "@aws-sdk/config-resolver";
-import { RegionInfoProvider } from "@aws-sdk/types";
-
-const regionHash: RegionHash = {};
-
-const partitionHash: PartitionHash = {
-  aws: {
-    regions: [
-      "af-south-1",
-      "ap-east-1",
-      "ap-northeast-1",
-      "ap-northeast-2",
-      "ap-northeast-3",
-      "ap-south-1",
-      "ap-southeast-1",
-      "ap-southeast-2",
-      "ca-central-1",
-      "eu-central-1",
-      "eu-north-1",
-      "eu-south-1",
-      "eu-west-1",
-      "eu-west-2",
-      "eu-west-3",
-      "me-south-1",
-      "sa-east-1",
-      "us-east-1",
-      "us-east-2",
-      "us-west-1",
-      "us-west-2",
-    ],
-    hostname: "textract.{region}.amazonaws.com",
-  },
-  "aws-cn": {
-    regions: ["cn-north-1", "cn-northwest-1"],
-    hostname: "textract.{region}.amazonaws.com.cn",
-  },
-  "aws-iso": {
-    regions: ["us-iso-east-1"],
-    hostname: "textract.{region}.c2s.ic.gov",
-  },
-  "aws-iso-b": {
-    regions: ["us-isob-east-1"],
-    hostname: "textract.{region}.sc2s.sgov.gov",
-  },
-  "aws-us-gov": {
-    regions: ["us-gov-east-1", "us-gov-west-1"],
-    hostname: "textract.{region}.amazonaws.com",
-  },
-};
-
-export const defaultRegionInfoProvider: RegionInfoProvider = async (region: string, options?: any) =>
-  getRegionInfo(region, {
-    ...options,
-    signingService: "textract",
-    regionHash,
-    partitionHash,
-  });

package/src/index.ts

@@ -1,10 +0,0 @@
-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";

package/src/models/index.ts

@@ -1 +0,0 @@
-export * from "./models_0";