@azure/ai-form-recognizer 5.0.0-alpha.20250227.1 → 5.0.0-alpha.20250228.2

package/dist/browser/documentAnalysisClient.d.ts

@@ -13,25 +13,27 @@ import type { ClassifyDocumentOptions } from "./options/ClassifyDocumentOptions.
  *
  * #### Azure Active Directory
  *
- * ```javascript
- * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+ * ```ts snippet:ReadmeSampleCreateClient_TokenCredential
  * import { DefaultAzureCredential } from "@azure/identity";
+ * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
  *
- * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
  * const credential = new DefaultAzureCredential();
- *
- * const client = new DocumentAnalysisClient(endpoint, credential);
+ * const client = new DocumentAnalysisClient(
+ *   "https://<resource name>.cognitiveservices.azure.com",
+ *   credential,
+ * );
  * ```
  *
  * #### API Key (Subscription Key)
  *
- * ```javascript
- * import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";
- *
- * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
- * const credential = new AzureKeyCredential("<api key>");
+ * ```ts snippet:ReadmeSampleCreateClient_KeyCredential
+ * import { AzureKeyCredential, DocumentAnalysisClient } from "@azure/ai-form-recognizer";
  *
- * const client = new DocumentAnalysisClient(endpoint, credential);
+ * const credential = new AzureKeyCredential("<API key>");
+ * const client = new DocumentAnalysisClient(
+ *   "https://<resource name>.cognitiveservices.azure.com",
+ *   credential,
+ * );
  * ```
  */
 export declare class DocumentAnalysisClient {
@@ -45,14 +47,15 @@ export declare class DocumentAnalysisClient {
      *
      * ### Example:
      *
-     * ```javascript
-     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * ```ts snippet:ReadmeSampleCreateClient_TokenCredential
      * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
      *
-     * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
      * const credential = new DefaultAzureCredential();
-     *
-     * const client = new DocumentAnalysisClient(endpoint, credential);
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      * ```
      *
      * @param endpoint - the endpoint URL of an Azure Cognitive Services instance
@@ -65,13 +68,14 @@ export declare class DocumentAnalysisClient {
      *
      * ### Example:
      *
-     * ```javascript
-     * import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";
-     *
-     * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
-     * const credential = new AzureKeyCredential("<api key>");
+     * ```ts snippet:ReadmeSampleCreateClient_KeyCredential
+     * import { AzureKeyCredential, DocumentAnalysisClient } from "@azure/ai-form-recognizer";
      *
-     * const client = new DocumentAnalysisClient(endpoint, credential);
+     * const credential = new AzureKeyCredential("<API key>");
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      * ```
      *
      * @param endpoint - the endpoint URL of an Azure Cognitive Services instance
@@ -99,32 +103,52 @@ export declare class DocumentAnalysisClient {
      * This method supports streamable request bodies ({@link FormRecognizerRequestBody}) such as Node.JS `ReadableStream`
      * objects, browser `Blob`s, and `ArrayBuffer`s. The contents of the body will be uploaded to the service for analysis.
      *
-     * ```javascript
-     * import * as fs from "fs";
+     * ```ts snippet:ReadmeSamplePrebuiltReceipt
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * import { createReadStream } from "node:fs";
+     * import { PrebuiltReceiptModel } from "../samples-dev/prebuilt/prebuilt-receipt.js";
+     *
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * const file = fs.createReadStream("path/to/receipt.pdf");
+     * const path = "<path to a document>";
+     * const readStream = createReadStream(path);
      *
-     * // The model that is passed to the following function call determines the type of the eventual result. In the
-     * // example, we will use the prebuilt receipt model, but you could use a custom model ID/name instead.
-     * const poller = await client.beginAnalyzeDocument("prebuilt-receipt", file);
+     * // The PrebuiltReceiptModel `DocumentModel` instance encodes both the model ID and a stronger return type for the operation
+     * const poller = await client.beginAnalyzeDocument(PrebuiltReceiptModel, readStream, {
+     *   onProgress: ({ status }) => {
+     *     console.log(`status: ${status}`);
+     *   },
+     * });
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
      * const {
-     *   pages, // pages extracted from the document, which contain lines and words
-     *   tables, // extracted tables, organized into cells that contain their contents
-     *   styles, // text styles (ex. handwriting) that were observed in the document
-     *   keyValuePairs, // extracted pairs of elements  (directed associations from one element in the input to another)
-     *   entities, // extracted entities in the input's content, which are categorized (ex. "Location" or "Organization")
-     *   documents // extracted documents (instances of one of the model's document types and its field schema)
+     *   documents: [receiptDocument],
      * } = await poller.pollUntilDone();
      *
-     * // Extract the fields of the first document. These fields constitute a receipt, because we used the receipt model
-     * const [{ fields: receipt }] = documents;
+     * // The fields of the document constitute the extracted receipt data.
+     * const receipt = receiptDocument.fields;
+     *
+     * if (receipt === undefined) {
+     *   throw new Error("Expected at least one receipt in analysis result.");
+     * }
+     *
+     * console.log(`Receipt data (${receiptDocument.docType})`);
+     * console.log("  Merchant Name:", receipt.merchantName?.value);
      *
-     * // The fields correspond to the model's document types and their field schemas. Refer to the Form Recognizer
-     * // documentation for information about the document types and field schemas within a model, or use the `getModel`
-     * // operation to view this information programmatically.
-     * console.log("The type of this receipt is:", receipt?.["ReceiptType"]?.value);
+     * // The items of the receipt are an example of a `DocumentArrayValue`
+     * if (receipt.items !== undefined) {
+     *   console.log("Items:");
+     *   for (const { properties: item } of receipt.items.values) {
+     *     console.log("- Description:", item.description?.value);
+     *     console.log("  Total Price:", item.totalPrice?.value);
+     *   }
+     * }
+     *
+     * console.log("  Total:", receipt.total?.value);
      * ```
      *
      *
@@ -149,35 +173,52 @@ export declare class DocumentAnalysisClient {
      * {@link beginAnalyzeDocumentFromUrl} method for more information. Use of that method is preferred when using URLs,
      * and URL support is only provided in this method for backwards compatibility.
      *
-     * ```typescript
-     * import * as fs from "fs";
+     * ```ts snippet:ReadmeSamplePrebuiltReceipt
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * import { createReadStream } from "node:fs";
+     * import { PrebuiltReceiptModel } from "../samples-dev/prebuilt/prebuilt-receipt.js";
      *
-     * // See the `prebuilt` folder in the SDK samples (http://aka.ms/azsdk/formrecognizer/js/samples) for examples of
-     * // DocumentModels for known prebuilts.
-     * import { PrebuiltReceiptModel } from "./prebuilt-receipt.ts";
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * const file = fs.createReadStream("path/to/receipt.pdf");
+     * const path = "<path to a document>";
+     * const readStream = createReadStream(path);
      *
-     * // The model that is passed to the following function call determines the type of the eventual result. In the
-     * // example, we will use the prebuilt receipt model.
-     * const poller = await client.beginAnalyzeDocument(PrebuiltReceiptModel, file);
+     * // The PrebuiltReceiptModel `DocumentModel` instance encodes both the model ID and a stronger return type for the operation
+     * const poller = await client.beginAnalyzeDocument(PrebuiltReceiptModel, readStream, {
+     *   onProgress: ({ status }) => {
+     *     console.log(`status: ${status}`);
+     *   },
+     * });
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
      * const {
-     *   pages, // pages extracted from the document, which contain lines and words
-     *   tables, // extracted tables, organized into cells that contain their contents
-     *   styles, // text styles (ex. handwriting) that were observed in the document
-     *   keyValuePairs, // extracted pairs of elements  (directed associations from one element in the input to another)
-     *
-     *   documents // extracted documents (instances of one of the model's document types and its field schema)
+     *   documents: [receiptDocument],
      * } = await poller.pollUntilDone();
      *
-     * // Extract the fields of the first document. These fields constitute a receipt, because we used the receipt model
-     * const [{ fields: receipt }] = documents;
+     * // The fields of the document constitute the extracted receipt data.
+     * const receipt = receiptDocument.fields;
+     *
+     * if (receipt === undefined) {
+     *   throw new Error("Expected at least one receipt in analysis result.");
+     * }
      *
-     * // Since we used the strongly-typed PrebuiltReceiptModel object instead of the "prebuilt-receipt" model ID
-     * // string, the fields of the receipt are strongly-typed and have camelCase names (as opposed to PascalCase).
-     * console.log("The type of this receipt is:", receipt.receiptType?.value);
+     * console.log(`Receipt data (${receiptDocument.docType})`);
+     * console.log("  Merchant Name:", receipt.merchantName?.value);
+     *
+     * // The items of the receipt are an example of a `DocumentArrayValue`
+     * if (receipt.items !== undefined) {
+     *   console.log("Items:");
+     *   for (const { properties: item } of receipt.items.values) {
+     *     console.log("- Description:", item.description?.value);
+     *     console.log("  Total Price:", item.totalPrice?.value);
+     *   }
+     * }
+     *
+     * console.log("  Total:", receipt.total?.value);
      * ```
      *
      * @param model - a {@link DocumentModel} representing the model to use for analysis and the expected output type
@@ -205,31 +246,46 @@ export declare class DocumentAnalysisClient {
      * token can be used to grant read access to a blob in Azure Storage, and the service will use the SAS-encoded URL to
      * request the file.
      *
-     * ```javascript
-     * // the URL must be publicly accessible
-     * const url = "<receipt document url>";
-     *
-     * // The model that is passed to the following function call determines the type of the eventual result. In the
-     * // example, we will use the prebuilt receipt model, but you could use a custom model ID/name instead.
-     * const poller = await client.beginAnalyzeDocument("prebuilt-receipt", url);
-     *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
-     * const {
-     *   pages, // pages extracted from the document, which contain lines and words
-     *   tables, // extracted tables, organized into cells that contain their contents
-     *   styles, // text styles (ex. handwriting) that were observed in the document
-     *   keyValuePairs, // extracted pairs of elements  (directed associations from one element in the input to another)
-     *
-     *   documents // extracted documents (instances of one of the model's document types and its field schema)
-     * } = await poller.pollUntilDone();
-     *
-     * // Extract the fields of the first document. These fields constitute a receipt, because we used the receipt model
-     * const [{ fields: receipt }] = documents;
+     * ```ts snippet:ReadmeSampleReceiptModelID_URL
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import {
+     *   DocumentAnalysisClient,
+     *   DocumentStringField,
+     *   DocumentArrayField,
+     *   DocumentObjectField,
+     * } from "@azure/ai-form-recognizer";
      *
-     * // The fields correspond to the model's document types and their field schemas. Refer to the Form Recognizer
-     * // documentation for information about the document types and field schemas within a model, or use the `getModel`
-     * // operation to view this information programmatically.
-     * console.log("The type of this receipt is:", receipt?.["ReceiptType"]?.value);
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
+     *
+     * const poller = await client.beginAnalyzeDocumentFromUrl(
+     *   "prebuilt-receipt",
+     *   // The Document Intelligence service will access the following URL to a receipt image and extract data from it
+     *   "https://raw.githubusercontent.com/Azure/azure-sdk-for-js/main/sdk/formrecognizer/ai-form-recognizer/assets/receipt/contoso-receipt.png",
+     * );
+     * poller.onProgress((state) => console.log("Operation:", state.modelId, state.status));
+     *
+     * const { documents } = await poller.pollUntilDone();
+     *
+     * const result = documents && documents[0];
+     * if (result) {
+     *   const receipt = result.fields;
+     *   console.log("=== Receipt Information ===");
+     *   console.log("Type:", result.docType);
+     *   console.log("Merchant:", (receipt["MerchantName"] as DocumentStringField).value);
+     *
+     *   console.log("Items:");
+     *   for (const { properties: item } of ((receipt["Items"] as DocumentArrayField).values ||
+     *     []) as DocumentObjectField[]) {
+     *     console.log("- Description:", (item["Description"] as DocumentStringField).value);
+     *     console.log("  Total Price:", (item["TotalPrice"] as DocumentStringField).value);
+     *   }
+     * } else {
+     *   throw new Error("Expected at least one receipt in the result.");
+     * }
      * ```
      *
      * @param modelId - the unique ID (name) of the model within this client's resource
@@ -251,34 +307,47 @@ export declare class DocumentAnalysisClient {
      * token can be used to grant read access to a blob in Azure Storage, and the service will use the SAS-encoded URL to
      * request the file.
      *
-     * ```typescript
-     * // See the `prebuilt` folder in the SDK samples (http://aka.ms/azsdk/formrecognizer/js/samples) for examples of
-     * // DocumentModels for known prebuilts.
-     * import { PrebuiltReceiptModel } from "./prebuilt-receipt.ts";
+     * ```ts snippet:ReadmeSampleReceiptPrebuilt_URL
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * import { PrebuiltReceiptModel } from "../samples-dev/prebuilt/prebuilt-receipt.js";
      *
-     * // the URL must be publicly accessible
-     * const url = "<receipt document url>";
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * // The model that is passed to the following function call determines the type of the eventual result. In the
-     * // example, we will use the prebuilt receipt model.
-     * const poller = await client.beginAnalyzeDocument(PrebuiltReceiptModel, url);
+     * const poller = await client.beginAnalyzeDocumentFromUrl(
+     *   PrebuiltReceiptModel,
+     *   // The Document Intelligence service will access the following URL to a receipt image and extract data from it
+     *   "https://raw.githubusercontent.com/Azure/azure-sdk-for-js/main/sdk/formrecognizer/ai-form-recognizer/assets/receipt/contoso-receipt.png",
+     * );
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
      * const {
-     *   pages, // pages extracted from the document, which contain lines and words
-     *   tables, // extracted tables, organized into cells that contain their contents
-     *   styles, // text styles (ex. handwriting) that were observed in the document
-     *   keyValuePairs, // extracted pairs of elements  (directed associations from one element in the input to another)
-     *
-     *   documents // extracted documents (instances of one of the model's document types and its field schema)
+     *   documents: [document],
      * } = await poller.pollUntilDone();
      *
-     * // Extract the fields of the first document. These fields constitute a receipt, because we used the receipt model
-     * const [{ fields: receipt }] = documents;
+     * // Use of PrebuiltModels.Receipt above (rather than the raw model ID), as it adds strong typing of the model's output
+     * if (document) {
+     *   const { merchantName, items, total } = document.fields;
+     *
+     *   console.log("=== Receipt Information ===");
+     *   console.log("Type:", document.docType);
+     *   console.log("Merchant:", merchantName && merchantName.value);
+     *
+     *   console.log("Items:");
+     *   for (const item of (items && items.values) || []) {
+     *     const { description, totalPrice } = item.properties;
+     *
+     *     console.log("- Description:", description && description.value);
+     *     console.log("  Total Price:", totalPrice && totalPrice.value);
+     *   }
      *
-     * // Since we used the strongly-typed PrebuiltReceiptModel object instead of the "prebuilt-receipt" model ID
-     * // string, the fields of the receipt are strongly-typed and have camelCase names (as opposed to PascalCase).
-     * console.log("The type of this receipt is:", receipt.receiptType?.value);
+     *   console.log("Total:", total && total.value);
+     * } else {
+     *   throw new Error("Expected at least one receipt in the result.");
+     * }
      * ```
      *
      * @param model - a {@link DocumentModel} representing the model to use for analysis and the expected output type
@@ -310,22 +379,32 @@ export declare class DocumentAnalysisClient {
      * This method supports streamable request bodies ({@link FormRecognizerRequestBody}) such as Node.JS `ReadableStream`
      * objects, browser `Blob`s, and `ArrayBuffer`s. The contents of the body will be uploaded to the service for analysis.
      *
-     * ```typescript
-     * import * as fs from "fs";
+     * ```ts snippet:ReadmeSampleClassifyDocument_File
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * import { createReadStream } from "node:fs";
+     *
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * const file = fs.createReadStream("path/to/file.pdf");
+     * const path = "<path to a document>";
+     * const readStream = createReadStream(path);
      *
-     * const poller = await client.beginClassifyDocument("<classifier ID>", file);
+     * const poller = await client.beginClassifyDocument("<classifier id>", readStream);
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
-     * const {
-     *   pages, // pages extracted from the document, which contain only basic information for classifiers
-     *   documents // extracted documents and their types
-     * } = await poller.pollUntilDone();
+     * const result = await poller.pollUntilDone();
      *
-     * // We'll print the documents and their types
-     * for (const { docType } of documents) {
-     *   console.log("The type of this document is:", docType);
+     * if (result?.documents?.length === 0) {
+     *   throw new Error("Failed to extract any documents.");
+     * }
+     *
+     * for (const document of result.documents) {
+     *   console.log(
+     *     `Extracted a document with type '${document.docType}' on page ${document.boundingRegions?.[0].pageNumber} (confidence: ${document.confidence})`,
+     *   );
      * }
      * ```
      *
@@ -351,21 +430,31 @@ export declare class DocumentAnalysisClient {
      * token can be used to grant read access to a blob in Azure Storage, and the service will use the SAS-encoded URL to
      * request the file.
      *
-     * ```typescript
-     * // the URL must be publicly accessible
-     * const url = "<file url>";
+     * ```ts snippet:ReadmeSampleClassifyDocument
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
      *
-     * const poller = await client.beginClassifyDocument("<classifier ID>", url);
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
-     * const {
-     *   pages, // pages extracted from the document, which contain only basic information for classifiers
-     *   documents // extracted documents and their types
-     * } = await poller.pollUntilDone();
+     * const documentUrl =
+     *   "https://raw.githubusercontent.com/Azure/azure-sdk-for-js/main/sdk/formrecognizer/ai-form-recognizer/assets/invoice/Invoice_1.pdf";
+     *
+     * const poller = await client.beginClassifyDocumentFromUrl("<classifier id>", documentUrl);
+     *
+     * const result = await poller.pollUntilDone();
+     *
+     * if (result?.documents?.length === 0) {
+     *   throw new Error("Failed to extract any documents.");
+     * }
      *
-     * // We'll print the documents and their types
-     * for (const { docType } of documents) {
-     *   console.log("The type of this document is:", docType);
+     * for (const document of result.documents) {
+     *   console.log(
+     *     `Extracted a document with type '${document.docType}' on page ${document.boundingRegions?.[0].pageNumber} (confidence: ${document.confidence})`,
+     *   );
      * }
      * ```
      * @param classifierId - the ID of the custom classifier to use for analysis

package/dist/browser/documentAnalysisClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"documentAnalysisClient.d.ts","sourceRoot":"","sources":["../../src/documentAnalysisClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAUvE,OAAO,KAAK,EAEV,cAAc,EAGd,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAO3B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,0CAA0C,CAAC;AAC9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAgB;IAEhC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBAED,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,eAAe,EAC3B,OAAO,CAAC,EAAE,6BAA6B;IAEzC;;;;;;;;;;;;;;;;;OAiBG;gBAED,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,aAAa,EACzB,OAAO,CAAC,EAAE,6BAA6B;IAEzC;;OAEG;gBAED,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,aAAa,GAAG,eAAe,EAC3C,OAAO,CAAC,EAAE,6BAA6B;IAiBzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACU,oBAAoB,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,yBAAyB,EAEnC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,cAAc,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACU,oBAAoB,CAAC,MAAM,EACtC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,QAAQ,EAAE,yBAAyB,EAEnC,OAAO,CAAC,EAAE,sBAAsB,CAAC,MAAM,CAAC,GACvC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAoBlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACU,2BAA2B,CACtC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAEnB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,cAAc,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACU,2BAA2B,CAAC,MAAM,EAC7C,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,WAAW,EAAE,MAAM,EAEnB,OAAO,CAAC,EAAE,sBAAsB,CAAC,MAAM,CAAC,GACvC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAclC;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO;IAiDf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACU,qBAAqB,CAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,yBAAyB,EAEnC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,cAAc,CAAC;IAQ1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACU,4BAA4B,CACvC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EAEnB,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,cAAc,CAAC;IAQ1B;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAuChB;;;;;;;;OAQG;YACW,mBAAmB;CA6JlC"}
+{"version":3,"file":"documentAnalysisClient.d.ts","sourceRoot":"","sources":["../../src/documentAnalysisClient.ts"],"names":[],"mappings":"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"}

package/dist/browser/documentAnalysisClient.js

@@ -15,25 +15,27 @@ import { makeServiceClient, Mappers, SERIALIZER } from "./util.js";
  *
  * #### Azure Active Directory
  *
- * ```javascript
- * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+ * ```ts snippet:ReadmeSampleCreateClient_TokenCredential
  * import { DefaultAzureCredential } from "@azure/identity";
+ * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
  *
- * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
  * const credential = new DefaultAzureCredential();
- *
- * const client = new DocumentAnalysisClient(endpoint, credential);
+ * const client = new DocumentAnalysisClient(
+ *   "https://<resource name>.cognitiveservices.azure.com",
+ *   credential,
+ * );
  * ```
  *
  * #### API Key (Subscription Key)
  *
- * ```javascript
- * import { DocumentAnalysisClient, AzureKeyCredential } from "@azure/ai-form-recognizer";
+ * ```ts snippet:ReadmeSampleCreateClient_KeyCredential
+ * import { AzureKeyCredential, DocumentAnalysisClient } from "@azure/ai-form-recognizer";
  *
- * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
- * const credential = new AzureKeyCredential("<api key>");
- *
- * const client = new DocumentAnalysisClient(endpoint, credential);
+ * const credential = new AzureKeyCredential("<API key>");
+ * const client = new DocumentAnalysisClient(
+ *   "https://<resource name>.cognitiveservices.azure.com",
+ *   credential,
+ * );
  * ```
  */
 export class DocumentAnalysisClient {
@@ -107,22 +109,32 @@ export class DocumentAnalysisClient {
      * This method supports streamable request bodies ({@link FormRecognizerRequestBody}) such as Node.JS `ReadableStream`
      * objects, browser `Blob`s, and `ArrayBuffer`s. The contents of the body will be uploaded to the service for analysis.
      *
-     * ```typescript
-     * import * as fs from "fs";
+     * ```ts snippet:ReadmeSampleClassifyDocument_File
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     * import { createReadStream } from "node:fs";
+     *
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
      *
-     * const file = fs.createReadStream("path/to/file.pdf");
+     * const path = "<path to a document>";
+     * const readStream = createReadStream(path);
      *
-     * const poller = await client.beginClassifyDocument("<classifier ID>", file);
+     * const poller = await client.beginClassifyDocument("<classifier id>", readStream);
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
-     * const {
-     *   pages, // pages extracted from the document, which contain only basic information for classifiers
-     *   documents // extracted documents and their types
-     * } = await poller.pollUntilDone();
+     * const result = await poller.pollUntilDone();
      *
-     * // We'll print the documents and their types
-     * for (const { docType } of documents) {
-     *   console.log("The type of this document is:", docType);
+     * if (result?.documents?.length === 0) {
+     *   throw new Error("Failed to extract any documents.");
+     * }
+     *
+     * for (const document of result.documents) {
+     *   console.log(
+     *     `Extracted a document with type '${document.docType}' on page ${document.boundingRegions?.[0].pageNumber} (confidence: ${document.confidence})`,
+     *   );
      * }
      * ```
      *
@@ -152,21 +164,31 @@ export class DocumentAnalysisClient {
      * token can be used to grant read access to a blob in Azure Storage, and the service will use the SAS-encoded URL to
      * request the file.
      *
-     * ```typescript
-     * // the URL must be publicly accessible
-     * const url = "<file url>";
+     * ```ts snippet:ReadmeSampleClassifyDocument
+     * import { DefaultAzureCredential } from "@azure/identity";
+     * import { DocumentAnalysisClient } from "@azure/ai-form-recognizer";
+     *
+     * const credential = new DefaultAzureCredential();
+     * const client = new DocumentAnalysisClient(
+     *   "https://<resource name>.cognitiveservices.azure.com",
+     *   credential,
+     * );
+     *
+     * const documentUrl =
+     *   "https://raw.githubusercontent.com/Azure/azure-sdk-for-js/main/sdk/formrecognizer/ai-form-recognizer/assets/invoice/Invoice_1.pdf";
      *
-     * const poller = await client.beginClassifyDocument("<classifier ID>", url);
+     * const poller = await client.beginClassifyDocumentFromUrl("<classifier id>", documentUrl);
      *
-     * // The result is a long-running operation (poller), which must itself be polled until the operation completes
-     * const {
-     *   pages, // pages extracted from the document, which contain only basic information for classifiers
-     *   documents // extracted documents and their types
-     * } = await poller.pollUntilDone();
+     * const result = await poller.pollUntilDone();
+     *
+     * if (result?.documents?.length === 0) {
+     *   throw new Error("Failed to extract any documents.");
+     * }
      *
-     * // We'll print the documents and their types
-     * for (const { docType } of documents) {
-     *   console.log("The type of this document is:", docType);
+     * for (const document of result.documents) {
+     *   console.log(
+     *     `Extracted a document with type '${document.docType}' on page ${document.boundingRegions?.[0].pageNumber} (confidence: ${document.confidence})`,
+     *   );
      * }
      * ```
      * @param classifierId - the ID of the custom classifier to use for analysis