generatedClient.ts

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is regenerated.
 */

import * as coreHttp from "@azure/core-http";
import * as Parameters from "./models/parameters";
import * as Mappers from "./models/mappers";
import { GeneratedClientContext } from "./generatedClientContext";
import {
  GeneratedClientOptionalParams,
  TrainRequest,
  GeneratedClientTrainCustomModelAsyncResponse,
  GeneratedClientGetCustomModelOptionalParams,
  GeneratedClientGetCustomModelResponse,
  ContentType,
  GeneratedClientAnalyzeWithCustomModel$binaryOptionalParams,
  GeneratedClientAnalyzeWithCustomModel$jsonOptionalParams,
  GeneratedClientAnalyzeWithCustomModelResponse,
  GeneratedClientGetAnalyzeFormResultResponse,
  CopyRequest,
  GeneratedClientCopyCustomModelResponse,
  GeneratedClientGetCustomModelCopyResultResponse,
  GeneratedClientGenerateModelCopyAuthorizationResponse,
  ComposeRequest,
  GeneratedClientComposeCustomModelsAsyncResponse,
  GeneratedClientAnalyzeBusinessCardAsync$binaryOptionalParams,
  GeneratedClientAnalyzeBusinessCardAsync$jsonOptionalParams,
  GeneratedClientAnalyzeBusinessCardAsyncResponse,
  GeneratedClientGetAnalyzeBusinessCardResultResponse,
  GeneratedClientAnalyzeInvoiceAsync$binaryOptionalParams,
  GeneratedClientAnalyzeInvoiceAsync$jsonOptionalParams,
  GeneratedClientAnalyzeInvoiceAsyncResponse,
  GeneratedClientGetAnalyzeInvoiceResultResponse,
  GeneratedClientAnalyzeReceiptAsync$binaryOptionalParams,
  GeneratedClientAnalyzeReceiptAsync$jsonOptionalParams,
  GeneratedClientAnalyzeReceiptAsyncResponse,
  GeneratedClientGetAnalyzeReceiptResultResponse,
  GeneratedClientAnalyzeLayoutAsync$binaryOptionalParams,
  GeneratedClientAnalyzeLayoutAsync$jsonOptionalParams,
  GeneratedClientAnalyzeLayoutAsyncResponse,
  GeneratedClientGetAnalyzeLayoutResultResponse,
  GeneratedClientListCustomModelsResponse,
  GeneratedClientGetCustomModelsResponse,
  GeneratedClientListCustomModelsNextResponse
} from "./models";

/** @hidden */
export class GeneratedClient extends GeneratedClientContext {
  /**
   * Initializes a new instance of the GeneratedClient class.
   * @param endpoint Supported Cognitive Services endpoints (protocol and hostname, for example:
   *                 https://westus2.api.cognitive.microsoft.com).
   * @param options The parameter options
   */
  constructor(endpoint: string, options?: GeneratedClientOptionalParams) {
    super(endpoint, options);
  }

  /**
   * Create and train a custom model. The request must include a source parameter that is either an
   * externally accessible Azure storage blob container Uri (preferably a Shared Access Signature Uri) or
   * valid path to a data folder in a locally mounted drive. When local paths are specified, they must
   * follow the Linux/Unix path format and be an absolute path rooted to the input mount configuration
   * setting value e.g., if '{Mounts:Input}' configuration setting value is '/input' then a valid source
   * path would be '/input/contosodataset'. All data to be trained is expected to be under the source
   * folder or sub folders under it. Models are trained using documents that are of the following content
   * type - 'application/pdf', 'image/jpeg', 'image/png', 'image/tiff'. Other type of content is ignored.
   * @param trainRequest Training request parameters.
   * @param options The options parameters.
   */
  trainCustomModelAsync(
    trainRequest: TrainRequest,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientTrainCustomModelAsyncResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      trainRequest,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      trainCustomModelAsyncOperationSpec
    ) as Promise<GeneratedClientTrainCustomModelAsyncResponse>;
  }

  /**
   * Get detailed information about a custom model.
   * @param modelId Model identifier.
   * @param options The options parameters.
   */
  getCustomModel(
    modelId: string,
    options?: GeneratedClientGetCustomModelOptionalParams
  ): Promise<GeneratedClientGetCustomModelResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      modelId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getCustomModelOperationSpec
    ) as Promise<GeneratedClientGetCustomModelResponse>;
  }

  /**
   * Mark model for deletion. Model artifacts will be permanently removed within a predetermined period.
   * @param modelId Model identifier.
   * @param options The options parameters.
   */
  deleteCustomModel(
    modelId: string,
    options?: coreHttp.OperationOptions
  ): Promise<coreHttp.RestResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      modelId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      deleteCustomModelOperationSpec
    ) as Promise<coreHttp.RestResponse>;
  }

  /**
   * Extract key-value pairs, tables, and semantic values from a given document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri or local path)
   * of the document to be analyzed.
   * @param modelId Model identifier.
   * @param contentType Upload file type
   * @param fileStream .json, .pdf, .jpg, .png or .tiff type file stream.
   * @param options The options parameters.
   */
  analyzeWithCustomModel(
    modelId: string,
    contentType: ContentType,
    fileStream: coreHttp.HttpRequestBody,
    options?: GeneratedClientAnalyzeWithCustomModel$binaryOptionalParams
  ): Promise<GeneratedClientAnalyzeWithCustomModelResponse>;
  /**
   * Extract key-value pairs, tables, and semantic values from a given document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri or local path)
   * of the document to be analyzed.
   * @param modelId Model identifier.
   * @param contentType Body Parameter content-type
   * @param options The options parameters.
   */
  analyzeWithCustomModel(
    modelId: string,
    contentType: "application/json",
    options?: GeneratedClientAnalyzeWithCustomModel$jsonOptionalParams
  ): Promise<GeneratedClientAnalyzeWithCustomModelResponse>;
  /**
   * Extract key-value pairs, tables, and semantic values from a given document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri or local path)
   * of the document to be analyzed.
   * @param args Includes all the parameters for this operation.
   */
  analyzeWithCustomModel(
    ...args:
      | [
          string,
          ContentType,
          coreHttp.HttpRequestBody,
          GeneratedClientAnalyzeWithCustomModel$binaryOptionalParams?
        ]
      | [
          string,
          "application/json",
          GeneratedClientAnalyzeWithCustomModel$jsonOptionalParams?
        ]
  ): Promise<GeneratedClientAnalyzeWithCustomModelResponse> {
    let operationSpec: coreHttp.OperationSpec;
    let operationArguments: coreHttp.OperationArguments;
    if (
      args[1] === "application/pdf" ||
      args[1] === "image/bmp" ||
      args[1] === "image/jpeg" ||
      args[1] === "image/png" ||
      args[1] === "image/tiff"
    ) {
      operationSpec = analyzeWithCustomModel$binaryOperationSpec;
      operationArguments = {
        modelId: args[0],
        contentType: args[1],
        fileStream: args[2],
        options: args[3]
      };
    } else if (args[1] === "application/json") {
      operationSpec = analyzeWithCustomModel$jsonOperationSpec;
      operationArguments = {
        modelId: args[0],
        contentType: args[1],
        options: args[2]
      };
    } else {
      throw new TypeError(
        `"contentType" must be a valid value but instead was "${args[1]}".`
      );
    }
    operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(
      operationArguments.options || {}
    );
    return this.sendOperationRequest(
      operationArguments,
      operationSpec
    ) as Promise<GeneratedClientAnalyzeWithCustomModelResponse>;
  }

  /**
   * Obtain current status and the result of the analyze form operation.
   * @param modelId Model identifier.
   * @param resultId Analyze operation result identifier.
   * @param options The options parameters.
   */
  getAnalyzeFormResult(
    modelId: string,
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetAnalyzeFormResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      modelId,
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getAnalyzeFormResultOperationSpec
    ) as Promise<GeneratedClientGetAnalyzeFormResultResponse>;
  }

  /**
   * Copy custom model stored in this resource (the source) to user specified target Form Recognizer
   * resource.
   * @param modelId Model identifier.
   * @param copyRequest Copy request parameters.
   * @param options The options parameters.
   */
  copyCustomModel(
    modelId: string,
    copyRequest: CopyRequest,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientCopyCustomModelResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      modelId,
      copyRequest,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      copyCustomModelOperationSpec
    ) as Promise<GeneratedClientCopyCustomModelResponse>;
  }

  /**
   * Obtain current status and the result of a custom model copy operation.
   * @param modelId Model identifier.
   * @param resultId Copy operation result identifier.
   * @param options The options parameters.
   */
  getCustomModelCopyResult(
    modelId: string,
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetCustomModelCopyResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      modelId,
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getCustomModelCopyResultOperationSpec
    ) as Promise<GeneratedClientGetCustomModelCopyResultResponse>;
  }

  /**
   * Generate authorization to copy a model into the target Form Recognizer resource.
   * @param options The options parameters.
   */
  generateModelCopyAuthorization(
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGenerateModelCopyAuthorizationResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      generateModelCopyAuthorizationOperationSpec
    ) as Promise<GeneratedClientGenerateModelCopyAuthorizationResponse>;
  }

  /**
   * Compose request would include list of models ids.
   * It would validate what all models either trained with labels model or composed model.
   * It would validate limit of models put together.
   * @param composeRequest Compose models
   * @param options The options parameters.
   */
  composeCustomModelsAsync(
    composeRequest: ComposeRequest,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientComposeCustomModelsAsyncResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      composeRequest,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      composeCustomModelsAsyncOperationSpec
    ) as Promise<GeneratedClientComposeCustomModelsAsyncResponse>;
  }

  /**
   * Extract field text and semantic values from a given business card document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri) of the
   * document to be analyzed.
   * @param contentType Upload file type
   * @param fileStream .json, .pdf, .jpg, .png or .tiff type file stream.
   * @param options The options parameters.
   */
  analyzeBusinessCardAsync(
    contentType: ContentType,
    fileStream: coreHttp.HttpRequestBody,
    options?: GeneratedClientAnalyzeBusinessCardAsync$binaryOptionalParams
  ): Promise<GeneratedClientAnalyzeBusinessCardAsyncResponse>;
  /**
   * Extract field text and semantic values from a given business card document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri) of the
   * document to be analyzed.
   * @param contentType Body Parameter content-type
   * @param options The options parameters.
   */
  analyzeBusinessCardAsync(
    contentType: "application/json",
    options?: GeneratedClientAnalyzeBusinessCardAsync$jsonOptionalParams
  ): Promise<GeneratedClientAnalyzeBusinessCardAsyncResponse>;
  /**
   * Extract field text and semantic values from a given business card document. The input document must
   * be of one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or
   * 'image/tiff'. Alternatively, use 'application/json' type to specify the location (Uri) of the
   * document to be analyzed.
   * @param args Includes all the parameters for this operation.
   */
  analyzeBusinessCardAsync(
    ...args:
      | [
          ContentType,
          coreHttp.HttpRequestBody,
          GeneratedClientAnalyzeBusinessCardAsync$binaryOptionalParams?
        ]
      | [
          "application/json",
          GeneratedClientAnalyzeBusinessCardAsync$jsonOptionalParams?
        ]
  ): Promise<GeneratedClientAnalyzeBusinessCardAsyncResponse> {
    let operationSpec: coreHttp.OperationSpec;
    let operationArguments: coreHttp.OperationArguments;
    if (
      args[0] === "application/pdf" ||
      args[0] === "image/bmp" ||
      args[0] === "image/jpeg" ||
      args[0] === "image/png" ||
      args[0] === "image/tiff"
    ) {
      operationSpec = analyzeBusinessCardAsync$binaryOperationSpec;
      operationArguments = {
        contentType: args[0],
        fileStream: args[1],
        options: args[2]
      };
    } else if (args[0] === "application/json") {
      operationSpec = analyzeBusinessCardAsync$jsonOperationSpec;
      operationArguments = { contentType: args[0], options: args[1] };
    } else {
      throw new TypeError(
        `"contentType" must be a valid value but instead was "${args[0]}".`
      );
    }
    operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(
      operationArguments.options || {}
    );
    return this.sendOperationRequest(
      operationArguments,
      operationSpec
    ) as Promise<GeneratedClientAnalyzeBusinessCardAsyncResponse>;
  }

  /**
   * Track the progress and obtain the result of the analyze business card operation.
   * @param resultId Analyze operation result identifier.
   * @param options The options parameters.
   */
  getAnalyzeBusinessCardResult(
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetAnalyzeBusinessCardResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getAnalyzeBusinessCardResultOperationSpec
    ) as Promise<GeneratedClientGetAnalyzeBusinessCardResultResponse>;
  }

  /**
   * Extract field text and semantic values from a given invoice document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param contentType Upload file type
   * @param fileStream .json, .pdf, .jpg, .png or .tiff type file stream.
   * @param options The options parameters.
   */
  analyzeInvoiceAsync(
    contentType: ContentType,
    fileStream: coreHttp.HttpRequestBody,
    options?: GeneratedClientAnalyzeInvoiceAsync$binaryOptionalParams
  ): Promise<GeneratedClientAnalyzeInvoiceAsyncResponse>;
  /**
   * Extract field text and semantic values from a given invoice document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param contentType Body Parameter content-type
   * @param options The options parameters.
   */
  analyzeInvoiceAsync(
    contentType: "application/json",
    options?: GeneratedClientAnalyzeInvoiceAsync$jsonOptionalParams
  ): Promise<GeneratedClientAnalyzeInvoiceAsyncResponse>;
  /**
   * Extract field text and semantic values from a given invoice document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param args Includes all the parameters for this operation.
   */
  analyzeInvoiceAsync(
    ...args:
      | [
          ContentType,
          coreHttp.HttpRequestBody,
          GeneratedClientAnalyzeInvoiceAsync$binaryOptionalParams?
        ]
      | [
          "application/json",
          GeneratedClientAnalyzeInvoiceAsync$jsonOptionalParams?
        ]
  ): Promise<GeneratedClientAnalyzeInvoiceAsyncResponse> {
    let operationSpec: coreHttp.OperationSpec;
    let operationArguments: coreHttp.OperationArguments;
    if (
      args[0] === "application/pdf" ||
      args[0] === "image/bmp" ||
      args[0] === "image/jpeg" ||
      args[0] === "image/png" ||
      args[0] === "image/tiff"
    ) {
      operationSpec = analyzeInvoiceAsync$binaryOperationSpec;
      operationArguments = {
        contentType: args[0],
        fileStream: args[1],
        options: args[2]
      };
    } else if (args[0] === "application/json") {
      operationSpec = analyzeInvoiceAsync$jsonOperationSpec;
      operationArguments = { contentType: args[0], options: args[1] };
    } else {
      throw new TypeError(
        `"contentType" must be a valid value but instead was "${args[0]}".`
      );
    }
    operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(
      operationArguments.options || {}
    );
    return this.sendOperationRequest(
      operationArguments,
      operationSpec
    ) as Promise<GeneratedClientAnalyzeInvoiceAsyncResponse>;
  }

  /**
   * Track the progress and obtain the result of the analyze invoice operation.
   * @param resultId Analyze operation result identifier.
   * @param options The options parameters.
   */
  getAnalyzeInvoiceResult(
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetAnalyzeInvoiceResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getAnalyzeInvoiceResultOperationSpec
    ) as Promise<GeneratedClientGetAnalyzeInvoiceResultResponse>;
  }

  /**
   * Extract field text and semantic values from a given receipt document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param contentType Upload file type
   * @param fileStream .json, .pdf, .jpg, .png or .tiff type file stream.
   * @param options The options parameters.
   */
  analyzeReceiptAsync(
    contentType: ContentType,
    fileStream: coreHttp.HttpRequestBody,
    options?: GeneratedClientAnalyzeReceiptAsync$binaryOptionalParams
  ): Promise<GeneratedClientAnalyzeReceiptAsyncResponse>;
  /**
   * Extract field text and semantic values from a given receipt document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param contentType Body Parameter content-type
   * @param options The options parameters.
   */
  analyzeReceiptAsync(
    contentType: "application/json",
    options?: GeneratedClientAnalyzeReceiptAsync$jsonOptionalParams
  ): Promise<GeneratedClientAnalyzeReceiptAsyncResponse>;
  /**
   * Extract field text and semantic values from a given receipt document. The input document must be of
   * one of the supported content types - 'application/pdf', 'image/jpeg', 'image/png' or 'image/tiff'.
   * Alternatively, use 'application/json' type to specify the location (Uri) of the document to be
   * analyzed.
   * @param args Includes all the parameters for this operation.
   */
  analyzeReceiptAsync(
    ...args:
      | [
          ContentType,
          coreHttp.HttpRequestBody,
          GeneratedClientAnalyzeReceiptAsync$binaryOptionalParams?
        ]
      | [
          "application/json",
          GeneratedClientAnalyzeReceiptAsync$jsonOptionalParams?
        ]
  ): Promise<GeneratedClientAnalyzeReceiptAsyncResponse> {
    let operationSpec: coreHttp.OperationSpec;
    let operationArguments: coreHttp.OperationArguments;
    if (
      args[0] === "application/pdf" ||
      args[0] === "image/bmp" ||
      args[0] === "image/jpeg" ||
      args[0] === "image/png" ||
      args[0] === "image/tiff"
    ) {
      operationSpec = analyzeReceiptAsync$binaryOperationSpec;
      operationArguments = {
        contentType: args[0],
        fileStream: args[1],
        options: args[2]
      };
    } else if (args[0] === "application/json") {
      operationSpec = analyzeReceiptAsync$jsonOperationSpec;
      operationArguments = { contentType: args[0], options: args[1] };
    } else {
      throw new TypeError(
        `"contentType" must be a valid value but instead was "${args[0]}".`
      );
    }
    operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(
      operationArguments.options || {}
    );
    return this.sendOperationRequest(
      operationArguments,
      operationSpec
    ) as Promise<GeneratedClientAnalyzeReceiptAsyncResponse>;
  }

  /**
   * Track the progress and obtain the result of the analyze receipt operation.
   * @param resultId Analyze operation result identifier.
   * @param options The options parameters.
   */
  getAnalyzeReceiptResult(
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetAnalyzeReceiptResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getAnalyzeReceiptResultOperationSpec
    ) as Promise<GeneratedClientGetAnalyzeReceiptResultResponse>;
  }

  /**
   * Extract text and layout information from a given document. The input document must be of one of the
   * supported content types - 'application/pdf', 'image/jpeg', 'image/png', 'image/tiff' or 'image/bmp'.
   * Alternatively, use 'application/json' type to specify the location (Uri or local path) of the
   * document to be analyzed.
   * @param contentType Upload file type
   * @param fileStream .json, .pdf, .jpg, .png or .tiff type file stream.
   * @param options The options parameters.
   */
  analyzeLayoutAsync(
    contentType: ContentType,
    fileStream: coreHttp.HttpRequestBody,
    options?: GeneratedClientAnalyzeLayoutAsync$binaryOptionalParams
  ): Promise<GeneratedClientAnalyzeLayoutAsyncResponse>;
  /**
   * Extract text and layout information from a given document. The input document must be of one of the
   * supported content types - 'application/pdf', 'image/jpeg', 'image/png', 'image/tiff' or 'image/bmp'.
   * Alternatively, use 'application/json' type to specify the location (Uri or local path) of the
   * document to be analyzed.
   * @param contentType Body Parameter content-type
   * @param options The options parameters.
   */
  analyzeLayoutAsync(
    contentType: "application/json",
    options?: GeneratedClientAnalyzeLayoutAsync$jsonOptionalParams
  ): Promise<GeneratedClientAnalyzeLayoutAsyncResponse>;
  /**
   * Extract text and layout information from a given document. The input document must be of one of the
   * supported content types - 'application/pdf', 'image/jpeg', 'image/png', 'image/tiff' or 'image/bmp'.
   * Alternatively, use 'application/json' type to specify the location (Uri or local path) of the
   * document to be analyzed.
   * @param args Includes all the parameters for this operation.
   */
  analyzeLayoutAsync(
    ...args:
      | [
          ContentType,
          coreHttp.HttpRequestBody,
          GeneratedClientAnalyzeLayoutAsync$binaryOptionalParams?
        ]
      | [
          "application/json",
          GeneratedClientAnalyzeLayoutAsync$jsonOptionalParams?
        ]
  ): Promise<GeneratedClientAnalyzeLayoutAsyncResponse> {
    let operationSpec: coreHttp.OperationSpec;
    let operationArguments: coreHttp.OperationArguments;
    if (
      args[0] === "application/pdf" ||
      args[0] === "image/bmp" ||
      args[0] === "image/jpeg" ||
      args[0] === "image/png" ||
      args[0] === "image/tiff"
    ) {
      operationSpec = analyzeLayoutAsync$binaryOperationSpec;
      operationArguments = {
        contentType: args[0],
        fileStream: args[1],
        options: args[2]
      };
    } else if (args[0] === "application/json") {
      operationSpec = analyzeLayoutAsync$jsonOperationSpec;
      operationArguments = { contentType: args[0], options: args[1] };
    } else {
      throw new TypeError(
        `"contentType" must be a valid value but instead was "${args[0]}".`
      );
    }
    operationArguments.options = coreHttp.operationOptionsToRequestOptionsBase(
      operationArguments.options || {}
    );
    return this.sendOperationRequest(
      operationArguments,
      operationSpec
    ) as Promise<GeneratedClientAnalyzeLayoutAsyncResponse>;
  }

  /**
   * Track the progress and obtain the result of the analyze layout operation
   * @param resultId Analyze operation result identifier.
   * @param options The options parameters.
   */
  getAnalyzeLayoutResult(
    resultId: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetAnalyzeLayoutResultResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      resultId,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getAnalyzeLayoutResultOperationSpec
    ) as Promise<GeneratedClientGetAnalyzeLayoutResultResponse>;
  }

  /**
   * Get information about all custom models
   * @param options The options parameters.
   */
  listCustomModels(
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientListCustomModelsResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      listCustomModelsOperationSpec
    ) as Promise<GeneratedClientListCustomModelsResponse>;
  }

  /**
   * Get information about all custom models
   * @param options The options parameters.
   */
  getCustomModels(
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientGetCustomModelsResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      getCustomModelsOperationSpec
    ) as Promise<GeneratedClientGetCustomModelsResponse>;
  }

  /**
   * ListCustomModelsNext
   * @param nextLink The nextLink from the previous successful call to the ListCustomModels method.
   * @param options The options parameters.
   */
  listCustomModelsNext(
    nextLink: string,
    options?: coreHttp.OperationOptions
  ): Promise<GeneratedClientListCustomModelsNextResponse> {
    const operationArguments: coreHttp.OperationArguments = {
      nextLink,
      options: coreHttp.operationOptionsToRequestOptionsBase(options || {})
    };
    return this.sendOperationRequest(
      operationArguments,
      listCustomModelsNextOperationSpec
    ) as Promise<GeneratedClientListCustomModelsNextResponse>;
  }
}
// Operation Specifications
const serializer = new coreHttp.Serializer(Mappers, /* isXml */ false);

const trainCustomModelAsyncOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models",
  httpMethod: "POST",
  responses: {
    201: {
      headersMapper: Mappers.GeneratedClientTrainCustomModelAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.trainRequest,
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType, Parameters.accept],
  mediaType: "json",
  serializer
};
const getCustomModelOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.Model
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  queryParameters: [Parameters.includeKeys],
  urlParameters: [Parameters.endpoint, Parameters.modelId],
  headerParameters: [Parameters.accept],
  serializer
};
const deleteCustomModelOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}",
  httpMethod: "DELETE",
  responses: {
    204: {},
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.modelId],
  headerParameters: [Parameters.accept],
  serializer
};
const analyzeWithCustomModel$binaryOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeWithCustomModelHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream,
  queryParameters: [Parameters.includeTextDetails],
  urlParameters: [Parameters.endpoint, Parameters.modelId],
  headerParameters: [Parameters.contentType1, Parameters.accept1],
  mediaType: "binary",
  serializer
};
const analyzeWithCustomModel$jsonOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeWithCustomModelHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream1,
  queryParameters: [Parameters.includeTextDetails],
  urlParameters: [Parameters.endpoint, Parameters.modelId],
  headerParameters: [Parameters.accept, Parameters.contentType2],
  mediaType: "json",
  serializer
};
const getAnalyzeFormResultOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}/analyzeResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.AnalyzeOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.modelId, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const copyCustomModelOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}/copy",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientCopyCustomModelHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.copyRequest,
  urlParameters: [Parameters.endpoint, Parameters.modelId],
  headerParameters: [Parameters.contentType, Parameters.accept],
  mediaType: "json",
  serializer
};
const getCustomModelCopyResultOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/{modelId}/copyResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.CopyOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.modelId, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const generateModelCopyAuthorizationOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/copyAuthorization",
  httpMethod: "POST",
  responses: {
    201: {
      bodyMapper: Mappers.CopyAuthorizationResult,
      headersMapper:
        Mappers.GeneratedClientGenerateModelCopyAuthorizationHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept],
  serializer
};
const composeCustomModelsAsyncOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models/compose",
  httpMethod: "POST",
  responses: {
    201: {
      headersMapper: Mappers.GeneratedClientComposeCustomModelsAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.composeRequest,
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType, Parameters.accept2],
  mediaType: "json",
  serializer
};
const analyzeBusinessCardAsync$binaryOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/businessCard/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeBusinessCardAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType1, Parameters.accept1],
  mediaType: "binary",
  serializer
};
const analyzeBusinessCardAsync$jsonOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/businessCard/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeBusinessCardAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream1,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept, Parameters.contentType2],
  mediaType: "json",
  serializer
};
const getAnalyzeBusinessCardResultOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/businessCard/analyzeResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.AnalyzeOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const analyzeInvoiceAsync$binaryOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/invoice/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeInvoiceAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType1, Parameters.accept1],
  mediaType: "binary",
  serializer
};
const analyzeInvoiceAsync$jsonOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/invoice/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeInvoiceAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream1,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept, Parameters.contentType2],
  mediaType: "json",
  serializer
};
const getAnalyzeInvoiceResultOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/invoice/analyzeResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.AnalyzeOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const analyzeReceiptAsync$binaryOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/receipt/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeReceiptAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType1, Parameters.accept1],
  mediaType: "binary",
  serializer
};
const analyzeReceiptAsync$jsonOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/receipt/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeReceiptAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream1,
  queryParameters: [Parameters.includeTextDetails, Parameters.locale],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept, Parameters.contentType2],
  mediaType: "json",
  serializer
};
const getAnalyzeReceiptResultOperationSpec: coreHttp.OperationSpec = {
  path: "/prebuilt/receipt/analyzeResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.AnalyzeOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const analyzeLayoutAsync$binaryOperationSpec: coreHttp.OperationSpec = {
  path: "/layout/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeLayoutAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream,
  queryParameters: [Parameters.language, Parameters.pages],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.contentType1, Parameters.accept1],
  mediaType: "binary",
  serializer
};
const analyzeLayoutAsync$jsonOperationSpec: coreHttp.OperationSpec = {
  path: "/layout/analyze",
  httpMethod: "POST",
  responses: {
    202: {
      headersMapper: Mappers.GeneratedClientAnalyzeLayoutAsyncHeaders
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  requestBody: Parameters.fileStream1,
  queryParameters: [Parameters.language, Parameters.pages],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept, Parameters.contentType2],
  mediaType: "json",
  serializer
};
const getAnalyzeLayoutResultOperationSpec: coreHttp.OperationSpec = {
  path: "/layout/analyzeResults/{resultId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.AnalyzeOperationResult
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  urlParameters: [Parameters.endpoint, Parameters.resultId],
  headerParameters: [Parameters.accept],
  serializer
};
const listCustomModelsOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.Models
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  queryParameters: [Parameters.op],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept],
  serializer
};
const getCustomModelsOperationSpec: coreHttp.OperationSpec = {
  path: "/custom/models",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.Models
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  queryParameters: [Parameters.op1],
  urlParameters: [Parameters.endpoint],
  headerParameters: [Parameters.accept],
  serializer
};
const listCustomModelsNextOperationSpec: coreHttp.OperationSpec = {
  path: "{nextLink}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.Models
    },
    default: {
      bodyMapper: Mappers.ErrorResponse
    }
  },
  queryParameters: [Parameters.op],
  urlParameters: [Parameters.endpoint, Parameters.nextLink],
  headerParameters: [Parameters.accept],
  serializer
};