@azure/ai-text-analytics 5.2.0-beta.1 → 6.0.0-alpha.20220517.2

package/types/ai-text-analytics.d.ts

@@ -1,3 +1,13 @@
+/**
+ * [Azure Cognitive Language Services](https://docs.microsoft.com/azure/cognitive-services/language-service/overview)
+ * is a suite of natural language processing (NLP) skills built with
+ * best-in-class Microsoft machine learning algorithms used to analyze
+ * unstructured text for actions such as sentiment analysis, key phrase
+ * extraction, and language detection.
+ *
+ * @packageDocumentation
+ */
+
 import { AzureKeyCredential } from '@azure/core-auth';
 import { CommonClientOptions } from '@azure/core-client';
 import { KeyCredential } from '@azure/core-auth';
@@ -7,355 +17,429 @@ import { PollerLike } from '@azure/core-lro';
 import { PollOperationState } from '@azure/core-lro';
 import { TokenCredential } from '@azure/core-auth';
 
-/**
- * An interface representing the state of an analysis poller operation.
- */
-export declare interface AnalysisPollOperationState<TResult> extends PollOperationState<TResult>, OperationMetadata {
+/** Configuration common to all actions. */
+export declare interface ActionCommon {
+    /**
+     * If set to true, you opt-out of having your text input logged for troubleshooting. By default, Cognitive Language Service logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this parameter to true, disables in logging and may limit our ability to remediate issues that occur.
+     *
+     * Default is false.
+     */
+    disableServiceLogs?: boolean;
 }
 
+/** Parameters object for a text analysis task using custom models. */
+export declare type ActionCustom = ActionCommon & {
+    projectName: string;
+    deploymentName: string;
+};
+
 /**
- * The metadata for beginAnalyzeActions operations.
+ * Action metadata.
  */
-export declare interface AnalyzeActionsOperationMetadata extends OperationMetadata {
-    /**
-     * Number of successfully completed actions.
-     */
-    actionsSucceededCount: number;
-    /**
-     * Number of failed actions.
-     */
-    actionsFailedCount: number;
-    /**
-     * Number of actions still in progress.
-     */
-    actionsInProgressCount: number;
+export declare interface ActionMetadata {
     /**
-     * The operation's display name.
+     * The model version used to perform the action.
      */
-    displayName?: string;
+    readonly modelVersion: string;
 }
 
+/** Configuration common to all actions that use prebuilt models. */
+export declare type ActionPrebuilt = ActionCommon & {
+    /** The version of the model to be used by the action. */
+    modelVersion?: string;
+};
+
 /**
- * The state of the begin analyze polling operation.
+ * Type of actions supported by the {@link TextAnalysisClient.analyze} method.
  */
-export declare interface AnalyzeActionsOperationState extends AnalysisPollOperationState<PagedAnalyzeActionsResult>, AnalyzeActionsOperationMetadata {
-}
+export declare type AnalyzeActionName = keyof typeof AnalyzeActionNames;
 
 /**
- * Result type of the Begin Analyze Actions Long-Running-Operation (LRO).
+ * Type of actions supported by the {@link TextAnalysisClient.analyze} method.
  */
-export declare type AnalyzeActionsPollerLike = PollerLike<AnalyzeActionsOperationState, PagedAnalyzeActionsResult>;
+export declare const AnalyzeActionNames: {
+    readonly EntityLinking: "EntityLinking";
+    readonly EntityRecognition: "EntityRecognition";
+    readonly KeyPhraseExtraction: "KeyPhraseExtraction";
+    readonly PiiEntityRecognition: "PiiEntityRecognition";
+    readonly LanguageDetection: "LanguageDetection";
+    readonly SentimentAnalysis: "SentimentAnalysis";
+};
 
 /**
- * The results of an analyze Actions operation.
+ * The type of parameters for every action in ${@link AnalyzeActionNames}.
  */
-export declare interface AnalyzeActionsResult {
-    /**
-     * Array of the results for each categorized entities recognition action.
-     */
-    recognizeEntitiesResults: RecognizeCategorizedEntitiesActionResult[];
-    /**
-     * Array of the results for each Pii entities recognition action.
-     */
-    recognizePiiEntitiesResults: RecognizePiiEntitiesActionResult[];
-    /**
-     * Array of the results for each key phrases extraction action.
-     */
-    extractKeyPhrasesResults: ExtractKeyPhrasesActionResult[];
-    /**
-     * Array of the results for each linked entities recognition action.
-     */
-    recognizeLinkedEntitiesResults: RecognizeLinkedEntitiesActionResult[];
-    /**
-     * Array of the results for each analyze sentiment action.
-     */
-    analyzeSentimentResults: AnalyzeSentimentActionResult[];
-    /**
-     * Array of the results for each extract summary action.
-     */
-    extractSummaryResults: ExtractSummaryActionResult[];
-}
+export declare type AnalyzeActionParameters<ActionName extends AnalyzeActionName> = {
+    EntityLinking: EntityLinkingAction;
+    EntityRecognition: EntityRecognitionAction;
+    PiiEntityRecognition: PiiEntityRecognitionAction;
+    KeyPhraseExtraction: KeyPhraseExtractionAction;
+    SentimentAnalysis: SentimentAnalysisAction;
+    LanguageDetection: LanguageDetectionAction;
+}[ActionName];
 
 /**
- * An error result from the healthcare operation on a single document.
+ * Batch of actions.
  */
-export declare type AnalyzeHealthcareEntitiesErrorResult = TextAnalyticsErrorResult;
+export declare type AnalyzeBatchAction = EntityLinkingBatchAction | EntityRecognitionBatchAction | KeyPhraseExtractionBatchAction | PiiEntityRecognitionBatchAction | HealthcareBatchAction | ExtractiveSummarizationBatchAction | SentimentAnalysisBatchAction | CustomEntityRecognitionBatchAction | CustomSingleLabelClassificationBatchAction | CustomMultiLabelClassificationBatchAction;
 
 /**
- * Result type of the Health Long-Running-Operation (LRO)
+ * Options common to all batch actions.
  */
-export declare type AnalyzeHealthcareEntitiesPollerLike = PollerLike<AnalyzeHealthcareOperationState, PagedAnalyzeHealthcareEntitiesResult>;
+export declare interface AnalyzeBatchActionCommon {
+    /**
+     * The name of the action.
+     */
+    actionName?: string;
+}
 
 /**
- * The result of the healthcare operation on a single document.
+ * Type of actions supported by the {@link TextAnalysisClient.beginAnalyzeBatch} method.
  */
-export declare type AnalyzeHealthcareEntitiesResult = AnalyzeHealthcareEntitiesSuccessResult | AnalyzeHealthcareEntitiesErrorResult;
+export declare type AnalyzeBatchActionName = keyof typeof AnalyzeBatchActionNames;
 
 /**
- * Array of {@link AnalyzeHealthcareEntitiesResult}
+ * Type of actions supported by the {@link TextAnalysisClient.beginAnalyzeBatch} method.
  */
-export declare interface AnalyzeHealthcareEntitiesResultArray extends Array<AnalyzeHealthcareEntitiesResult> {
-}
+export declare const AnalyzeBatchActionNames: {
+    readonly SentimentAnalysis: "SentimentAnalysis";
+    readonly EntityRecognition: "EntityRecognition";
+    readonly PiiEntityRecognition: "PiiEntityRecognition";
+    readonly KeyPhraseExtraction: "KeyPhraseExtraction";
+    readonly EntityLinking: "EntityLinking";
+    readonly Healthcare: "Healthcare";
+    readonly ExtractiveSummarization: "ExtractiveSummarization";
+    readonly CustomEntityRecognition: "CustomEntityRecognition";
+    readonly CustomSingleLabelClassification: "CustomSingleLabelClassification";
+    readonly CustomMultiLabelClassification: "CustomMultiLabelClassification";
+};
 
 /**
- * The results of a successful healthcare operation for a single document.
+ * The metadata for long-running operations started by {@link TextAnalysisClient.beginAnalyzeBatch}.
  */
-export declare interface AnalyzeHealthcareEntitiesSuccessResult extends TextAnalyticsSuccessResult {
+export declare interface AnalyzeBatchOperationMetadata {
     /**
-     * Healthcare entities.
+     * The date and time the operation was created.
      */
-    entities: HealthcareEntity[];
+    readonly createdOn: Date;
     /**
-     * Relations between healthcare entities.
+     * The date and time when the operation results will expire on the server.
      */
-    entityRelations: HealthcareEntityRelation[];
-}
-
-/**
- * The state of the begin analyze healthcare polling operation.
- */
-export declare interface AnalyzeHealthcareOperationState extends AnalysisPollOperationState<PagedAnalyzeHealthcareEntitiesResult> {
-}
-
-/**
- * Options for an analyze sentiment action.
- */
-export declare interface AnalyzeSentimentAction extends TextAnalyticsAction {
+    readonly expiresOn?: Date;
     /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     * The operation id.
      */
-    stringIndexType?: StringIndexType;
+    readonly operationId: string;
     /**
-     * If set to true, you opt-out of having your text input logged for troubleshooting. By default, Text Analytics
-     * logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this parameter to true,
-     * disables input logging and may limit our ability to remediate issues that occur.
+     * The time the operation status was last updated.
      */
-    disableServiceLogs?: boolean;
+    readonly lastModifiedOn: Date;
     /**
-     * Whether to mine the opinions of a sentence and conduct more  granular
-     * analysis around the aspects of a product or service (also known as
-     * aspect-based sentiment analysis). If set to true, the returned
-     * `SentenceSentiment` objects will have property `opinions` containing
-     * the result of this analysis.
-     * More information about the feature can be found here: {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-how-to-sentiment-analysis?tabs=version-3-1#opinion-mining}
+     * The current status of the operation.
      */
-    includeOpinionMining?: boolean;
+    readonly status: OperationStatus;
+    /**
+     * Number of successfully completed actions.
+     */
+    readonly actionSucceededCount: number;
+    /**
+     * Number of failed actions.
+     */
+    readonly actionFailedCount: number;
+    /**
+     * Number of actions still in progress.
+     */
+    readonly actionInProgressCount: number;
+    /**
+     * The operation's display name.
+     */
+    readonly displayName?: string;
 }
 
 /**
- * The error of an analyze sentiment action.
+ * The state of the begin analyze polling operation.
  */
-export declare type AnalyzeSentimentActionErrorResult = TextAnalyticsActionErrorResult;
+export declare interface AnalyzeBatchOperationState extends PollOperationState<PagedAnalyzeBatchResult>, AnalyzeBatchOperationMetadata {
+}
 
 /**
- * The result of an analyze sentiment action.
+ * A poller that polls long-running operations started by {@link TextAnalysisClient.beginAnalyzeBatch}.
  */
-export declare type AnalyzeSentimentActionResult = AnalyzeSentimentActionSuccessResult | AnalyzeSentimentActionErrorResult;
+export declare type AnalyzeBatchPoller = PollerLike<AnalyzeBatchOperationState, PagedAnalyzeBatchResult>;
 
 /**
- * The results of a succeeded analyze sentiment action.
+ * Results of a batch of actions.
  */
-export declare interface AnalyzeSentimentActionSuccessResult extends TextAnalyticsActionSuccessState {
-    /**
-     * Array of the results for each analyze sentiment action.
-     */
-    results: AnalyzeSentimentResultArray;
-}
+export declare type AnalyzeBatchResult = EntityLinkingBatchResult | EntityRecognitionBatchResult | KeyPhraseExtractionBatchResult | PiiEntityRecognitionBatchResult | SentimentAnalysisBatchResult | HealthcareBatchResult | ExtractiveSummarizationBatchResult | CustomEntityRecognitionBatchResult | CustomSingleLabelClassificationBatchResult | CustomMultiLabelClassificationBatchResult;
 
 /**
- * An error result from the analyze sentiment operation on a single document.
+ * The type of results of every action in ${@link AnalyzeActionNames}.
  */
-export declare type AnalyzeSentimentErrorResult = TextAnalyticsErrorResult;
+export declare type AnalyzeResult<ActionName extends AnalyzeActionName> = {
+    EntityLinking: EntityLinkingResult[];
+    EntityRecognition: EntityRecognitionResult[];
+    PiiEntityRecognition: PiiEntityRecognitionResult[];
+    KeyPhraseExtraction: KeyPhraseExtractionResult[];
+    SentimentAnalysis: SentimentAnalysisResult[];
+    LanguageDetection: LanguageDetectionResult[];
+}[ActionName];
+
+/** An object that contains the predicted sentiment, confidence scores and other information about an assessment of a target. For example, in the sentence "The food is good", the assessment of the target 'food' is 'good'. */
+export declare interface AssessmentSentiment {
+    /** Assessment sentiment in the sentence. */
+    sentiment: TokenSentimentLabel;
+    /** Assessment sentiment confidence scores in the sentence. */
+    confidenceScores: TargetConfidenceScores;
+    /** The assessment offset from the start of the sentence. */
+    offset: number;
+    /** The length of the assessment. */
+    length: number;
+    /** The assessment text detected. */
+    text: string;
+    /** The indicator representing if the assessment is negated. */
+    isNegated: boolean;
+}
+
+/** Defines values for Association. */
+export declare type Association = "subject" | "other";
+
+export { AzureKeyCredential }
 
 /**
- * Options for the analyze sentiment operation.
+ * The error of an analyze batch action.
  */
-export declare interface AnalyzeSentimentOptions extends TextAnalyticsOperationOptions {
+export declare interface BatchActionErrorResult<Kind extends AnalyzeBatchActionName> extends BatchActionState<Kind> {
     /**
-     * Whether to mine the opinions of a sentence and conduct more  granular
-     * analysis around the aspects of a product or service (also known as
-     * aspect-based sentiment analysis). If set to true, the returned
-     * `SentenceSentiment` objects will have property `opinions` containing
-     * the result of this analysis.
-     * More information about the feature can be found here: {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-how-to-sentiment-analysis?tabs=version-3-1#opinion-mining}
+     * When this action was completed by the service.
      */
-    includeOpinionMining?: boolean;
+    readonly failedOn: Date;
     /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     * The Error for this action result.
      */
-    stringIndexType?: StringIndexType;
+    readonly error: TextAnalysisError;
 }
 
 /**
- * The result of the analyze sentiment operation on a single document.
+ * The result of a batched action.
  */
-export declare type AnalyzeSentimentResult = AnalyzeSentimentSuccessResult | AnalyzeSentimentErrorResult;
+export declare type BatchActionResult<T, Kind extends AnalyzeBatchActionName> = BatchActionSuccessResult<T, Kind> | BatchActionErrorResult<Kind>;
 
-/**
- * Array of `AnalyzeSentimentResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
- */
-export declare interface AnalyzeSentimentResultArray extends Array<AnalyzeSentimentResult> {
+/** The State of a batched action */
+export declare interface BatchActionState<Kind extends AnalyzeBatchActionName> {
     /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * The kind of the action results.
      */
-    statistics?: TextDocumentBatchStatistics;
+    readonly kind: Kind;
     /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
+     * The name of the action.
      */
-    modelVersion: string;
+    readonly actionName?: string;
+    /**
+     * Action statistics.
+     */
+    readonly statistics?: TextDocumentBatchStatistics;
 }
 
 /**
- *  The result of the analyze sentiment operation on a single document,
- *  containing the predicted sentiment for each sentence as well as for the full document.
+ * The state of a succeeded batched action.
  */
-export declare interface AnalyzeSentimentSuccessResult extends TextAnalyticsSuccessResult {
+export declare interface BatchActionSuccessResult<T, Kind extends AnalyzeBatchActionName> extends BatchActionState<Kind> {
     /**
-     * Predicted sentiment for document. Possible values
-     * include: 'positive', 'neutral', 'negative', 'mixed'
+     * The list of document results.
      */
-    sentiment: DocumentSentimentLabel;
+    readonly results: T[];
     /**
-     * Document level sentiment confidence scores between 0 and 1 for each sentiment class.
+     * When this action was completed by the service.
      */
-    confidenceScores: SentimentConfidenceScores;
+    readonly completedOn: Date;
     /**
-     * The predicted sentiment for each sentence in the corresponding document.
+     * Discriminant to determine if that this is an error result.
      */
-    sentences: SentenceSentiment[];
-}
-
-/**
- * AssessmentSentiment contains the predicted sentiment, confidence scores and
- * other information about an assessment of a target. For example, in the sentence
- * "The food is good", the assessment of the target 'food' is 'good'.
- */
-export declare interface AssessmentSentiment extends SentenceAssessment {
+    readonly error?: undefined;
 }
-export { AzureKeyCredential }
 
 /**
  * Options for the begin analyze actions operation.
  */
-export declare interface BeginAnalyzeActionsOptions extends OperationOptions {
+export declare interface BeginAnalyzeBatchOptions extends TextAnalysisOperationOptions {
     /**
-     * Delay to wait until next poll, in milliseconds.
+     * Time delay between poll requests, in milliseconds.
      */
     updateIntervalInMs?: number;
-    /**
-     * A serialized poller which can be used to resume an existing paused Long-Running-Operation.
-     */
-    resumeFrom?: string;
-    /**
-     * If set to true, response will contain input and document level statistics.
-     */
-    includeStatistics?: boolean;
     /**
      * The operation's display name.
      */
     displayName?: string;
 }
 
+/** Defines values for Certainty. */
+export declare type Certainty = "positive" | "positivePossible" | "neutralPossible" | "negativePossible" | "negative";
+
+/** A classification result from a custom classify document single category action */
+export declare interface ClassificationCategory {
+    /** Classification type. */
+    category: string;
+    /** Confidence score between 0 and 1 of the recognized class. */
+    confidenceScore: number;
+}
+
+/** Defines values for Conditionality. */
+export declare type Conditionality = "hypothetical" | "conditional";
+
 /**
- * Options for the begin analyze healthcare entities operation.
+ * Custom action metadata.
  */
-export declare interface BeginAnalyzeHealthcareEntitiesOptions extends TextAnalyticsOperationOptions {
+export declare interface CustomActionMetadata {
     /**
-     * Delay to wait until next poll, in milliseconds.
+     * The name of the project used to perform the action.
      */
-    stringIndexType?: StringIndexType;
+    readonly projectName: string;
     /**
-     * Delay to wait until next poll, in milliseconds.
+     * The name of the deployment used to perform the action.
      */
-    updateIntervalInMs?: number;
+    readonly deploymentName: string;
+}
+
+/** Supported parameters for a Custom Entities task. */
+export declare type CustomEntityRecognitionAction = ActionCustom & {
+    /**
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     */
+    stringIndexType?: StringIndexType;
+};
+
+/** Options for a custom entity recognition batch action. */
+export declare interface CustomEntityRecognitionBatchAction extends AnalyzeBatchActionCommon, CustomEntityRecognitionAction {
     /**
-     * A serialized poller which can be used to resume an existing paused Long-Running-Operation.
+     * The kind of the action.
      */
-    resumeFrom?: string;
+    kind: "CustomEntityRecognition";
 }
 
 /**
- * An entity from text analysis with information about its categorical
- * classification.
+ * The result of a custom entity recognition batch action.
  */
-export declare interface CategorizedEntity extends Entity {
-}
+export declare type CustomEntityRecognitionBatchResult = CustomActionMetadata & BatchActionResult<CustomEntityRecognitionResult, "CustomEntityRecognition">;
 
-/** Information about the language of a document as identified by the Text Analytics service. */
-export declare interface DetectedLanguage {
-    /** Long name of a detected language (e.g. English, French). */
-    name: string;
-    /** A two letter representation of the detected language according to the ISO 639-1 standard (e.g. en, fr). */
-    iso6391Name: string;
-    /** A confidence score between 0 and 1. Scores close to 1 indicate 100% certainty that the identified language is true. */
-    confidenceScore: number;
-}
+/**
+ * An error result from the recognize custom entities operation on a single document.
+ */
+export declare type CustomEntityRecognitionErrorResult = TextAnalysisErrorResult;
 
 /**
- * An error result from the detect languge operation on a single document.
+ * The result of the custom recognize entities operation on a single document.
  */
-export declare type DetectLanguageErrorResult = TextAnalyticsErrorResult;
+export declare type CustomEntityRecognitionResult = CustomEntityRecognitionSuccessResult | CustomEntityRecognitionErrorResult;
 
-/** An input to the language detection operation. This object specifies a unique document id, as well as the full text of a document and a hint indicating the document's country of origin to assist the text analytics predictive model in detecting the document's language. */
-export declare interface DetectLanguageInput {
-    /** Unique, non-empty document identifier. */
-    id: string;
-    text: string;
-    countryHint?: string;
+/**
+ * The result of the recognize custom entities operation on a single document,
+ * containing a collection of the entities identified in that document.
+ */
+export declare interface CustomEntityRecognitionSuccessResult extends TextAnalysisSuccessResult {
+    /**
+     * The collection of entities identified in the input document.
+     */
+    readonly entities: Entity[];
+}
+
+/** Options for a multi-label classification custom action */
+export declare type CustomMultiLabelClassificationAction = ActionCustom;
+
+/** Options for a custom multi-label classification batch action. */
+export declare interface CustomMultiLabelClassificationBatchAction extends AnalyzeBatchActionCommon, CustomMultiLabelClassificationAction {
+    /**
+     * The kind of the action.
+     */
+    kind: "CustomMultiLabelClassification";
 }
 
 /**
- * Options for the detect languages operation.
+ * The result of a custom multi-label classification batch action.
  */
-export declare interface DetectLanguageOptions extends TextAnalyticsOperationOptions {
-}
+export declare type CustomMultiLabelClassificationBatchResult = CustomActionMetadata & BatchActionResult<CustomMultiLabelClassificationResult, "CustomMultiLabelClassification">;
+
+/**
+ * An error result from the custom classify document multi category operation on a multi document.
+ */
+export declare type CustomMultiLabelClassificationErrorResult = TextAnalysisErrorResult;
 
 /**
- * The result of the detect language operation on a single document.
+ * The result of the custom classify document multi categories operation on a multi document.
  */
-export declare type DetectLanguageResult = DetectLanguageSuccessResult | DetectLanguageErrorResult;
+export declare type CustomMultiLabelClassificationResult = CustomMultiLabelClassificationSuccessResult | CustomMultiLabelClassificationErrorResult;
 
 /**
- * Array of `DetectLanguageResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
+ * The result of the custom classify document multi categories operation on a multi document,
+ * containing the result of the classification.
  */
-export declare interface DetectLanguageResultArray extends Array<DetectLanguageResult> {
+export declare interface CustomMultiLabelClassificationSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * The collection of classifications in the input document.
      */
-    statistics?: TextDocumentBatchStatistics;
+    readonly classifications: ClassificationCategory[];
+}
+
+/** Options for a single-label classification custom action */
+export declare type CustomSingleLabelClassificationAction = ActionCustom;
+
+/** Options for a custom single-label classification batch action. */
+export declare interface CustomSingleLabelClassificationBatchAction extends AnalyzeBatchActionCommon, CustomSingleLabelClassificationAction {
     /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
+     * The kind of the action.
      */
-    modelVersion: string;
+    kind: "CustomSingleLabelClassification";
 }
 
 /**
- * The result of the detect language operation on a single document,
- * containing a prediction of what language the document is written in.
+ * The result of a custom single-label classification batch action.
+ */
+export declare type CustomSingleLabelClassificationBatchResult = CustomActionMetadata & BatchActionResult<CustomSingleLabelClassificationResult, "CustomSingleLabelClassification">;
+
+/**
+ * An error result from the custom classify document single category operation on a single document.
+ */
+export declare type CustomSingleLabelClassificationErrorResult = TextAnalysisErrorResult;
+
+/**
+ * The result of the custom classify document single category operation on a single document.
+ */
+export declare type CustomSingleLabelClassificationResult = CustomSingleLabelClassificationSuccessResult | CustomSingleLabelClassificationErrorResult;
+
+/**
+ * The result of the custom classify document single category operation on a single document,
+ * containing the result of the classification.
  */
-export declare interface DetectLanguageSuccessResult extends TextAnalyticsSuccessResult {
+export declare interface CustomSingleLabelClassificationSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * The top detected language by confidence score.
+     * The collection of classifications in the input document.
      */
-    readonly primaryLanguage: DetectedLanguage;
+    readonly classifications: ClassificationCategory[];
+}
+
+/** Information about the language of a document as identified by the Language service. */
+export declare interface DetectedLanguage {
+    /** Long name of a detected language (e.g. English, French). */
+    name: string;
+    /** A two letter representation of the detected language according to the ISO 639-1 standard (e.g. en, fr). */
+    iso6391Name: string;
+    /** A confidence score between 0 and 1. Scores close to 1 indicate 100% certainty that the identified language is true. */
+    confidenceScore: number;
 }
 
 /** Defines values for DocumentSentimentLabel. */
 export declare type DocumentSentimentLabel = "positive" | "neutral" | "negative" | "mixed";
 
-/** A word or phrase identified as an entity that is categorized within a taxonomy of types. The set of categories recognized by the Text Analytics service is described at https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/named-entity-types . */
+/** Represents a warning encountered while processing a document. */
+export declare interface DocumentWarning {
+    /** Error code. */
+    code: WarningCode;
+    /** Warning message. */
+    message: string;
+}
+
+/** A word or phrase identified as an entity that is categorized within a taxonomy of types. The set of categories recognized by the Language service is described at https://docs.microsoft.com/azure/cognitive-services/language-service/named-entity-recognition/concepts/named-entity-categories . */
 export declare interface Entity {
     /** Entity text as appears in the request. */
     text: string;
@@ -371,222 +455,181 @@ export declare interface Entity {
     confidenceScore: number;
 }
 
-export declare interface EntityAssertion {
-    /** Describes any conditionality on the entity. */
-    conditionality?: EntityConditionality;
-    /** Describes the entities certainty and polarity. */
-    certainty?: EntityCertainty;
-    /** Describes if the entity is the subject of the text or if it describes someone else. */
-    association?: EntityAssociation;
+/** A type representing a reference for the healthcare entity into a specific entity catalog. */
+export declare interface EntityDataSource {
+    /** Entity Catalog. Examples include: UMLS, CHV, MSH, etc. */
+    name: string;
+    /** Entity id in the given source catalog. */
+    entityId: string;
 }
 
-/** Defines values for Association. */
-export declare type EntityAssociation = "subject" | "other";
-
-/** Defines values for Certainty. */
-export declare type EntityCertainty = "positive" | "positivePossible" | "neutralPossible" | "negativePossible" | "negative";
-
-/** Defines values for Conditionality. */
-export declare type EntityConditionality = "hypothetical" | "conditional";
-
-/**
- * A type representing a reference for the healthcare entity into a specific
- * entity catalog.
- */
-export declare interface EntityDataSource {
+/** Options for an entity linking action. */
+export declare type EntityLinkingAction = ActionPrebuilt & {
     /**
-     * Entity Catalog. Examples include: UMLS, CHV, MSH, etc.
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
      */
-    name: string;
+    stringIndexType?: StringIndexType;
+};
+
+/** Options for an entity linking batch action. */
+export declare interface EntityLinkingBatchAction extends AnalyzeBatchActionCommon, EntityLinkingAction {
     /**
-     * Entity id in the given source catalog.
+     * The kind of the action.
      */
-    entityId: string;
+    kind: "EntityLinking";
 }
 
 /**
- * An Error Code returned from the Text Analytics service. Possible
- * values include:
- *
- * For more information about the error, see the `message` property of the associated error.
+ * The result of an entity linking batch action.
  */
-export declare type ErrorCode = ErrorCodeValue | InnerErrorCodeValue;
+export declare type EntityLinkingBatchResult = ActionMetadata & BatchActionResult<EntityLinkingResult, "EntityLinking">;
 
 /**
- * Defines values for ErrorCodeValue. \
- * {@link KnownErrorCodeValue} can be used interchangeably with ErrorCodeValue,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **InvalidRequest** \
- * **InvalidArgument** \
- * **InternalServerError** \
- * **ServiceUnavailable** \
- * **NotFound**
+ * An error result from an entity linking action on a single document.
  */
-export declare type ErrorCodeValue = string;
+export declare type EntityLinkingErrorResult = TextAnalysisErrorResult;
 
 /**
- * Options for a key phrases recognition action.
+ * The result of an entity linking action on a single document.
  */
-export declare interface ExtractKeyPhrasesAction extends TextAnalyticsAction {
-    /**
-     * If set to false, you opt-in to have your text input logged for troubleshooting. By default, Text Analytics
-     * will not log your input text for pii entities recognition. Setting this parameter to false,
-     * enables input logging.
-     */
-    disableServiceLogs?: boolean;
-}
+export declare type EntityLinkingResult = EntityLinkingSuccessResult | EntityLinkingErrorResult;
 
 /**
- * The error of a extract key phrases action.
+ * The result of a entity linking action on a single document, containing a
+ * collection of the {@link LinkedEntity} objects identified in that document.
  */
-export declare type ExtractKeyPhrasesActionErrorResult = TextAnalyticsActionErrorResult;
+export declare interface EntityLinkingSuccessResult extends TextAnalysisSuccessResult {
+    /**
+     * The collection of entities identified in the input document.
+     */
+    readonly entities: LinkedEntity[];
+}
 
-/**
- * The result of a extract key phrases action.
- */
-export declare type ExtractKeyPhrasesActionResult = ExtractKeyPhrasesActionSuccessResult | ExtractKeyPhrasesActionErrorResult;
+/** Options for an entity recognition action. */
+export declare type EntityRecognitionAction = ActionPrebuilt & {
+    /**
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     */
+    stringIndexType?: StringIndexType;
+};
 
-/**
- * The results of a succeeded extract key phrases action.
- */
-export declare interface ExtractKeyPhrasesActionSuccessResult extends TextAnalyticsActionSuccessState {
+/** Options for an entity recognition batch action. */
+export declare interface EntityRecognitionBatchAction extends AnalyzeBatchActionCommon, EntityRecognitionAction {
     /**
-     * Array of the results for each extract key phrases action.
+     * The kind of the action.
      */
-    results: ExtractKeyPhrasesResultArray;
+    kind: "EntityRecognition";
 }
 
 /**
- * An error result from the extract key phrases operation on a single document.
+ * The result of an entity recognition batch action.
  */
-export declare type ExtractKeyPhrasesErrorResult = TextAnalyticsErrorResult;
+export declare type EntityRecognitionBatchResult = ActionMetadata & BatchActionResult<EntityRecognitionResult, "EntityRecognition">;
 
 /**
- * Options for the extract key phrases operation.
+ * An error result from an entity recognition action on a single document.
  */
-export declare interface ExtractKeyPhrasesOptions extends TextAnalyticsOperationOptions {
-}
+export declare type EntityRecognitionErrorResult = TextAnalysisErrorResult;
 
 /**
- * The result of the extract key phrases operation on a single document.
+ * The result of an entity recognition action on a single document.
  */
-export declare type ExtractKeyPhrasesResult = ExtractKeyPhrasesSuccessResult | ExtractKeyPhrasesErrorResult;
+export declare type EntityRecognitionResult = EntityRecognitionSuccessResult | EntityRecognitionErrorResult;
 
 /**
- * Array of `ExtractKeyPhrasesResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
+ * The result of an entity recognition action on a single document, containing
+ * a collection of {@link Entity} objects identified in that document.
  */
-export declare interface ExtractKeyPhrasesResultArray extends Array<ExtractKeyPhrasesResult> {
-    /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
-     */
-    statistics?: TextDocumentBatchStatistics;
+export declare interface EntityRecognitionSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
+     * The collection of entities identified in the input document.
      */
-    modelVersion: string;
+    readonly entities: Entity[];
 }
 
-/**
- * The result of the extract key phrases operation on a single document,
- * containing a collection of the key phrases identified in that document.
- */
-export declare interface ExtractKeyPhrasesSuccessResult extends TextAnalyticsSuccessResult {
+/** Supported parameters for an Extractive Summarization task. */
+export declare type ExtractiveSummarizationAction = ActionPrebuilt & {
+    maxSentenceCount?: number;
+    /** The sorting criteria to use for the results of Extractive Summarization. */
+    orderBy?: ExtractiveSummarizationOrderingCriteria;
     /**
-     * A list of representative words or phrases. The number of key phrases returned is proportional
-     * to the number of words in the input document.
-     */
-    keyPhrases: string[];
-}
-
-/**
- * Options for an extract summary action.
- */
-export declare interface ExtractSummaryAction extends TextAnalyticsAction {
-    /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
      */
     stringIndexType?: StringIndexType;
+};
+
+/** Options for an extractive summarization batch action. */
+export declare interface ExtractiveSummarizationBatchAction extends AnalyzeBatchActionCommon, ExtractiveSummarizationAction {
     /**
-     * If set to true, you opt-out of having your text input logged for troubleshooting. By default, Text Analytics
-     * logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this parameter to true,
-     * disables input logging and may limit our ability to remediate issues that occur.
-     */
-    disableServiceLogs?: boolean;
-    /**
-     * Specifies the number of summary sentences to return. The default number of sentences is 3.
-     */
-    maxSentenceCount?: number;
-    /**
-     * Specifies how to sort the returned sentences. Please refer to {@link KnownSummarySentencesSortBy} for possible values.
+     * The kind of the action.
      */
-    orderBy?: string;
+    kind: "ExtractiveSummarization";
 }
 
 /**
- * The error of an extract summary action.
+ * The result of an extractive summarization batch action.
  */
-export declare type ExtractSummaryActionErrorResult = TextAnalyticsActionErrorResult;
+export declare type ExtractiveSummarizationBatchResult = ActionMetadata & BatchActionResult<SummarizationExtractionResult, "ExtractiveSummarization">;
 
 /**
- * The result of an extract summary action.
+ * Defines values for ExtractiveSummarizationOrderingCriteria. \
+ * {@link KnownExtractiveSummarizationOrderingCriteria} can be used interchangeably with ExtractiveSummarizationOrderingCriteria,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Offset**: Indicates that results should be sorted in order of appearance in the text. \
+ * **Rank**: Indicates that results should be sorted in order of importance (i.e. rank score) according to the model.
  */
-export declare type ExtractSummaryActionResult = ExtractSummaryActionSuccessResult | ExtractSummaryActionErrorResult;
+export declare type ExtractiveSummarizationOrderingCriteria = string;
 
 /**
- * The results of a succeeded extract summary action.
+ * Defines values for FhirVersion. \
+ * {@link KnownFhirVersion} can be used interchangeably with FhirVersion,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **4.0.1**
  */
-export declare interface ExtractSummaryActionSuccessResult extends TextAnalyticsActionSuccessState {
+export declare type FhirVersion = string;
+
+/** Supported parameters for a Healthcare task. */
+export declare type HealthcareAction = ActionPrebuilt & {
+    /** The FHIR Spec version that the result will use to format the fhirBundle. For additional information see https://www.hl7.org/fhir/overview.html. */
+    fhirVersion?: FhirVersion;
     /**
-     * Array of the results for each extract summary action.
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
      */
-    results: ExtractSummaryResultArray;
-}
-
-/**
- * An error result from the extract summary operation on a single document.
- */
-export declare type ExtractSummaryErrorResult = TextAnalyticsErrorResult;
+    stringIndexType?: StringIndexType;
+};
 
-/**
- * The result of the extract summary operation on a single document.
- */
-export declare type ExtractSummaryResult = ExtractSummarySuccessResult | ExtractSummaryErrorResult;
+/** An object that describes metadata about the healthcare entity such as whether it is hypothetical or conditional. */
+export declare interface HealthcareAssertion {
+    /** Describes any conditionality on the entity. */
+    conditionality?: Conditionality;
+    /** Describes the entities certainty and polarity. */
+    certainty?: Certainty;
+    /** Describes if the entity is the subject of the text or if it describes someone else. */
+    association?: Association;
+}
 
-/**
- * Array of `ExtractSummaryResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
- */
-export declare interface ExtractSummaryResultArray extends Array<ExtractSummaryResult> {
+/** Options for a healthcare batch action. */
+export declare interface HealthcareBatchAction extends AnalyzeBatchActionCommon, HealthcareAction {
     /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * The kind of the action.
      */
-    statistics?: TextDocumentBatchStatistics;
-    /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
-     */
-    modelVersion: string;
+    kind: "Healthcare";
 }
 
 /**
- * The result of the extract summary operation on a single document,
- * containing a collection of the summary identified in that document.
+ * The result of a healthcare batch action.
  */
-export declare interface ExtractSummarySuccessResult extends TextAnalyticsSuccessResult {
-    /**
-     * A list of sentences composing a summary of the input document.
-     */
-    sentences: SummarySentence[];
-}
+export declare type HealthcareBatchResult = ActionMetadata & BatchActionResult<HealthcareResult, "Healthcare">;
 
 /**
  * A healthcare entity represented as a node in a directed graph where the edges are
@@ -596,15 +639,15 @@ export declare interface HealthcareEntity extends Entity {
     /**
      * Normalized name for the entity. For example, the normalized text for "histologically" is "histologic".
      */
-    normalizedText?: string;
+    readonly normalizedText?: string;
     /**
      * Whether the entity is negated.
      */
-    assertion?: EntityAssertion;
+    readonly assertion?: HealthcareAssertion;
     /**
      * Entity references in known data sources.
      */
-    dataSources: EntityDataSource[];
+    readonly dataSources: EntityDataSource[];
     /**
      * Defines values for HealthcareEntityCategory.
      * {@link KnownHealthcareEntityCategory} can be used interchangeably with HealthcareEntityCategory,
@@ -637,7 +680,7 @@ export declare interface HealthcareEntity extends Entity {
      * **FAMILY_RELATION**
      * **TREATMENT_NAME**
      */
-    category: HealthcareEntityCategory;
+    readonly category: HealthcareEntityCategory;
 }
 
 /**
@@ -681,11 +724,11 @@ export declare interface HealthcareEntityRelation {
     /**
      * The type of the healthcare relation.
      */
-    relationType: HealthcareEntityRelationType;
+    readonly relationType: RelationType;
     /**
      * The list of healthcare entities and their roles in the healthcare relation.
      */
-    roles: HealthcareEntityRelationRole[];
+    readonly roles: HealthcareEntityRelationRole[];
 }
 
 /**
@@ -695,11 +738,11 @@ export declare interface HealthcareEntityRelationRole {
     /**
      * A healthcare entity
      */
-    entity: HealthcareEntity;
+    readonly entity: HealthcareEntity;
     /**
      * The role of the healthcare entity in a particular relation.
      */
-    name: HealthcareEntityRelationRoleType;
+    readonly name: HealthcareEntityRelationRoleType;
 }
 
 /**
@@ -708,87 +751,117 @@ export declare interface HealthcareEntityRelationRole {
 export declare type HealthcareEntityRelationRoleType = string;
 
 /**
- * Defines values for RelationType. \
- * {@link KnownRelationType} can be used interchangeably with RelationType,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **Abbreviation** \
- * **DirectionOfBodyStructure** \
- * **DirectionOfCondition** \
- * **DirectionOfExamination** \
- * **DirectionOfTreatment** \
- * **DosageOfMedication** \
- * **FormOfMedication** \
- * **FrequencyOfMedication** \
- * **FrequencyOfTreatment** \
- * **QualifierOfCondition** \
- * **RelationOfExamination** \
- * **RouteOfMedication** \
- * **TimeOfCondition** \
- * **TimeOfEvent** \
- * **TimeOfExamination** \
- * **TimeOfMedication** \
- * **TimeOfTreatment** \
- * **UnitOfCondition** \
- * **UnitOfExamination** \
- * **ValueOfCondition** \
- * **ValueOfExamination**
+ * An error result from the healthcare operation on a single document.
  */
-export declare type HealthcareEntityRelationType = string;
+export declare type HealthcareErrorResult = TextAnalysisErrorResult;
 
 /**
- * Defines values for InnerErrorCodeValue. \
- * {@link KnownInnerErrorCodeValue} can be used interchangeably with InnerErrorCodeValue,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **InvalidParameterValue** \
- * **InvalidRequestBodyFormat** \
- * **EmptyRequest** \
- * **MissingInputRecords** \
- * **InvalidDocument** \
- * **ModelVersionIncorrect** \
- * **InvalidDocumentBatch** \
- * **UnsupportedLanguageCode** \
- * **InvalidCountryHint**
- */
-export declare type InnerErrorCodeValue = string;
-
-/** Known values of {@link HealthcareEntityCategory} that the service accepts. */
-export declare enum KnownHealthcareEntityCategory {
-    BodyStructure = "BODY_STRUCTURE",
-    AGE = "AGE",
-    Gender = "GENDER",
-    ExaminationName = "EXAMINATION_NAME",
-    Date = "DATE",
-    Direction = "DIRECTION",
-    Frequency = "FREQUENCY",
-    MeasurementValue = "MEASUREMENT_VALUE",
-    MeasurementUnit = "MEASUREMENT_UNIT",
-    RelationalOperator = "RELATIONAL_OPERATOR",
-    Time = "TIME",
-    GeneORProtein = "GENE_OR_PROTEIN",
-    Variant = "VARIANT",
-    AdministrativeEvent = "ADMINISTRATIVE_EVENT",
-    CareEnvironment = "CARE_ENVIRONMENT",
-    HealthcareProfession = "HEALTHCARE_PROFESSION",
-    Diagnosis = "DIAGNOSIS",
-    SymptomORSign = "SYMPTOM_OR_SIGN",
-    ConditionQualifier = "CONDITION_QUALIFIER",
-    MedicationClass = "MEDICATION_CLASS",
-    MedicationName = "MEDICATION_NAME",
-    Dosage = "DOSAGE",
-    MedicationForm = "MEDICATION_FORM",
-    MedicationRoute = "MEDICATION_ROUTE",
-    FamilyRelation = "FAMILY_RELATION",
-    TreatmentName = "TREATMENT_NAME"
-}
-
-/** Known values of {@link InnerErrorCodeValue} that the service accepts. */
-export declare enum KnownInnerErrorCodeValue {
+ * The result of the healthcare operation on a single document.
+ */
+export declare type HealthcareResult = HealthcareSuccessResult | HealthcareErrorResult;
+
+/**
+ * The results of a successful healthcare operation for a single document.
+ */
+export declare interface HealthcareSuccessResult extends TextAnalysisSuccessResult {
+    /**
+     * Healthcare entities.
+     */
+    readonly entities: HealthcareEntity[];
+    /**
+     * Relations between healthcare entities.
+     */
+    readonly entityRelations: HealthcareEntityRelation[];
+    /**
+     * JSON bundle containing a FHIR compatible object for consumption in other
+     * Healthcare tools. For additional information see {@link https://www.hl7.org/fhir/overview.html}.
+     */
+    readonly fhirBundle?: Record<string, any>;
+}
+
+/** Options for a key phrase recognition action. */
+export declare type KeyPhraseExtractionAction = ActionPrebuilt;
+
+/** Options for an key phrase extraction batch action. */
+export declare interface KeyPhraseExtractionBatchAction extends AnalyzeBatchActionCommon, KeyPhraseExtractionAction {
+    /**
+     * The kind of the action.
+     */
+    kind: "KeyPhraseExtraction";
+}
+
+/**
+ * The result of a key phrase extraction batch action.
+ */
+export declare type KeyPhraseExtractionBatchResult = ActionMetadata & BatchActionResult<KeyPhraseExtractionResult, "KeyPhraseExtraction">;
+
+/**
+ * An error result from a key phrase extraction action on a single document.
+ */
+export declare type KeyPhraseExtractionErrorResult = TextAnalysisErrorResult;
+
+/**
+ * The result of a sentiment analysis action on a single document.
+ */
+export declare type KeyPhraseExtractionResult = KeyPhraseExtractionSuccessResult | KeyPhraseExtractionErrorResult;
+
+/**
+ * The result of a key phrase extraction action on a single document,
+ * containing a collection of the key phrases identified in that document.
+ */
+export declare interface KeyPhraseExtractionSuccessResult extends TextAnalysisSuccessResult {
+    /**
+     * A list of representative words or phrases. The number of key phrases
+     * returned is proportional to the number of words in the input document.
+     */
+    readonly keyPhrases: string[];
+}
+
+/** Known values of {@link ErrorCode} that the service accepts. */
+export declare enum KnownErrorCode {
+    InvalidRequest = "InvalidRequest",
+    InvalidArgument = "InvalidArgument",
+    Unauthorized = "Unauthorized",
+    Forbidden = "Forbidden",
+    NotFound = "NotFound",
+    ProjectNotFound = "ProjectNotFound",
+    OperationNotFound = "OperationNotFound",
+    AzureCognitiveSearchNotFound = "AzureCognitiveSearchNotFound",
+    AzureCognitiveSearchIndexNotFound = "AzureCognitiveSearchIndexNotFound",
+    TooManyRequests = "TooManyRequests",
+    AzureCognitiveSearchThrottling = "AzureCognitiveSearchThrottling",
+    AzureCognitiveSearchIndexLimitReached = "AzureCognitiveSearchIndexLimitReached",
+    InternalServerError = "InternalServerError",
+    ServiceUnavailable = "ServiceUnavailable"
+}
+
+/** Known values of {@link ExtractiveSummarizationOrderingCriteria} that the service accepts. */
+export declare enum KnownExtractiveSummarizationOrderingCriteria {
+    /** Indicates that results should be sorted in order of appearance in the text. */
+    Offset = "Offset",
+    /** Indicates that results should be sorted in order of importance (i.e. rank score) according to the model. */
+    Rank = "Rank"
+}
+
+/**
+ * Known values of the {@link HealthcareAction.fhirVersion} parameter.
+ */
+export declare enum KnownFhirVersion {
+    /** 4.0.1 */
+    "4.0.1" = "4.0.1"
+}
+
+/** Known values of {@link InnerErrorCode} that the service accepts. */
+export declare enum KnownInnerErrorCode {
+    InvalidRequest = "InvalidRequest",
     InvalidParameterValue = "InvalidParameterValue",
+    KnowledgeBaseNotFound = "KnowledgeBaseNotFound",
+    AzureCognitiveSearchNotFound = "AzureCognitiveSearchNotFound",
+    AzureCognitiveSearchThrottling = "AzureCognitiveSearchThrottling",
+    ExtractionFailure = "ExtractionFailure",
     InvalidRequestBodyFormat = "InvalidRequestBodyFormat",
     EmptyRequest = "EmptyRequest",
-    MissingInputRecords = "MissingInputRecords",
+    MissingInputDocuments = "MissingInputDocuments",
     InvalidDocument = "InvalidDocument",
     ModelVersionIncorrect = "ModelVersionIncorrect",
     InvalidDocumentBatch = "InvalidDocumentBatch",
@@ -796,15 +869,264 @@ export declare enum KnownInnerErrorCodeValue {
     InvalidCountryHint = "InvalidCountryHint"
 }
 
+/** Known values of {@link PiiCategory} that the service accepts. */
+export declare enum KnownPiiCategory {
+    ABARoutingNumber = "ABARoutingNumber",
+    ARNationalIdentityNumber = "ARNationalIdentityNumber",
+    AUBankAccountNumber = "AUBankAccountNumber",
+    AUDriversLicenseNumber = "AUDriversLicenseNumber",
+    AUMedicalAccountNumber = "AUMedicalAccountNumber",
+    AUPassportNumber = "AUPassportNumber",
+    AUTaxFileNumber = "AUTaxFileNumber",
+    AUBusinessNumber = "AUBusinessNumber",
+    AUCompanyNumber = "AUCompanyNumber",
+    ATIdentityCard = "ATIdentityCard",
+    ATTaxIdentificationNumber = "ATTaxIdentificationNumber",
+    ATValueAddedTaxNumber = "ATValueAddedTaxNumber",
+    AzureDocumentDBAuthKey = "AzureDocumentDBAuthKey",
+    AzureIaasDatabaseConnectionAndSQLString = "AzureIAASDatabaseConnectionAndSQLString",
+    AzureIoTConnectionString = "AzureIoTConnectionString",
+    AzurePublishSettingPassword = "AzurePublishSettingPassword",
+    AzureRedisCacheString = "AzureRedisCacheString",
+    AzureSAS = "AzureSAS",
+    AzureServiceBusString = "AzureServiceBusString",
+    AzureStorageAccountKey = "AzureStorageAccountKey",
+    AzureStorageAccountGeneric = "AzureStorageAccountGeneric",
+    BENationalNumber = "BENationalNumber",
+    BENationalNumberV2 = "BENationalNumberV2",
+    BEValueAddedTaxNumber = "BEValueAddedTaxNumber",
+    BrcpfNumber = "BRCPFNumber",
+    BRLegalEntityNumber = "BRLegalEntityNumber",
+    BRNationalIdrg = "BRNationalIDRG",
+    BGUniformCivilNumber = "BGUniformCivilNumber",
+    CABankAccountNumber = "CABankAccountNumber",
+    CADriversLicenseNumber = "CADriversLicenseNumber",
+    CAHealthServiceNumber = "CAHealthServiceNumber",
+    CAPassportNumber = "CAPassportNumber",
+    CAPersonalHealthIdentification = "CAPersonalHealthIdentification",
+    CASocialInsuranceNumber = "CASocialInsuranceNumber",
+    CLIdentityCardNumber = "CLIdentityCardNumber",
+    CNResidentIdentityCardNumber = "CNResidentIdentityCardNumber",
+    CreditCardNumber = "CreditCardNumber",
+    HRIdentityCardNumber = "HRIdentityCardNumber",
+    HRNationalIDNumber = "HRNationalIDNumber",
+    HRPersonalIdentificationNumber = "HRPersonalIdentificationNumber",
+    HRPersonalIdentificationOIBNumberV2 = "HRPersonalIdentificationOIBNumberV2",
+    CYIdentityCard = "CYIdentityCard",
+    CYTaxIdentificationNumber = "CYTaxIdentificationNumber",
+    CZPersonalIdentityNumber = "CZPersonalIdentityNumber",
+    CZPersonalIdentityV2 = "CZPersonalIdentityV2",
+    DKPersonalIdentificationNumber = "DKPersonalIdentificationNumber",
+    DKPersonalIdentificationV2 = "DKPersonalIdentificationV2",
+    DrugEnforcementAgencyNumber = "DrugEnforcementAgencyNumber",
+    EEPersonalIdentificationCode = "EEPersonalIdentificationCode",
+    EUDebitCardNumber = "EUDebitCardNumber",
+    EUDriversLicenseNumber = "EUDriversLicenseNumber",
+    EugpsCoordinates = "EUGPSCoordinates",
+    EUNationalIdentificationNumber = "EUNationalIdentificationNumber",
+    EUPassportNumber = "EUPassportNumber",
+    EUSocialSecurityNumber = "EUSocialSecurityNumber",
+    EUTaxIdentificationNumber = "EUTaxIdentificationNumber",
+    FIEuropeanHealthNumber = "FIEuropeanHealthNumber",
+    FINationalID = "FINationalID",
+    FINationalIDV2 = "FINationalIDV2",
+    FIPassportNumber = "FIPassportNumber",
+    FRDriversLicenseNumber = "FRDriversLicenseNumber",
+    FRHealthInsuranceNumber = "FRHealthInsuranceNumber",
+    FRNationalID = "FRNationalID",
+    FRPassportNumber = "FRPassportNumber",
+    FRSocialSecurityNumber = "FRSocialSecurityNumber",
+    FRTaxIdentificationNumber = "FRTaxIdentificationNumber",
+    FRValueAddedTaxNumber = "FRValueAddedTaxNumber",
+    DEDriversLicenseNumber = "DEDriversLicenseNumber",
+    DEPassportNumber = "DEPassportNumber",
+    DEIdentityCardNumber = "DEIdentityCardNumber",
+    DETaxIdentificationNumber = "DETaxIdentificationNumber",
+    DEValueAddedNumber = "DEValueAddedNumber",
+    GRNationalIDCard = "GRNationalIDCard",
+    GRNationalIDV2 = "GRNationalIDV2",
+    GRTaxIdentificationNumber = "GRTaxIdentificationNumber",
+    HKIdentityCardNumber = "HKIdentityCardNumber",
+    HUValueAddedNumber = "HUValueAddedNumber",
+    HUPersonalIdentificationNumber = "HUPersonalIdentificationNumber",
+    HUTaxIdentificationNumber = "HUTaxIdentificationNumber",
+    INPermanentAccount = "INPermanentAccount",
+    INUniqueIdentificationNumber = "INUniqueIdentificationNumber",
+    IDIdentityCardNumber = "IDIdentityCardNumber",
+    InternationalBankingAccountNumber = "InternationalBankingAccountNumber",
+    IEPersonalPublicServiceNumber = "IEPersonalPublicServiceNumber",
+    IEPersonalPublicServiceNumberV2 = "IEPersonalPublicServiceNumberV2",
+    ILBankAccountNumber = "ILBankAccountNumber",
+    ILNationalID = "ILNationalID",
+    ITDriversLicenseNumber = "ITDriversLicenseNumber",
+    ITFiscalCode = "ITFiscalCode",
+    ITValueAddedTaxNumber = "ITValueAddedTaxNumber",
+    JPBankAccountNumber = "JPBankAccountNumber",
+    JPDriversLicenseNumber = "JPDriversLicenseNumber",
+    JPPassportNumber = "JPPassportNumber",
+    JPResidentRegistrationNumber = "JPResidentRegistrationNumber",
+    JPSocialInsuranceNumber = "JPSocialInsuranceNumber",
+    JPMyNumberCorporate = "JPMyNumberCorporate",
+    JPMyNumberPersonal = "JPMyNumberPersonal",
+    JPResidenceCardNumber = "JPResidenceCardNumber",
+    LVPersonalCode = "LVPersonalCode",
+    LTPersonalCode = "LTPersonalCode",
+    LUNationalIdentificationNumberNatural = "LUNationalIdentificationNumberNatural",
+    LUNationalIdentificationNumberNonNatural = "LUNationalIdentificationNumberNonNatural",
+    MYIdentityCardNumber = "MYIdentityCardNumber",
+    MTIdentityCardNumber = "MTIdentityCardNumber",
+    MTTaxIDNumber = "MTTaxIDNumber",
+    NLCitizensServiceNumber = "NLCitizensServiceNumber",
+    NLCitizensServiceNumberV2 = "NLCitizensServiceNumberV2",
+    NLTaxIdentificationNumber = "NLTaxIdentificationNumber",
+    NLValueAddedTaxNumber = "NLValueAddedTaxNumber",
+    NZBankAccountNumber = "NZBankAccountNumber",
+    NZDriversLicenseNumber = "NZDriversLicenseNumber",
+    NZInlandRevenueNumber = "NZInlandRevenueNumber",
+    NZMinistryOfHealthNumber = "NZMinistryOfHealthNumber",
+    NZSocialWelfareNumber = "NZSocialWelfareNumber",
+    NOIdentityNumber = "NOIdentityNumber",
+    PHUnifiedMultiPurposeIDNumber = "PHUnifiedMultiPurposeIDNumber",
+    PLIdentityCard = "PLIdentityCard",
+    PLNationalID = "PLNationalID",
+    PLNationalIDV2 = "PLNationalIDV2",
+    PLPassportNumber = "PLPassportNumber",
+    PLTaxIdentificationNumber = "PLTaxIdentificationNumber",
+    PlregonNumber = "PLREGONNumber",
+    PTCitizenCardNumber = "PTCitizenCardNumber",
+    PTCitizenCardNumberV2 = "PTCitizenCardNumberV2",
+    PTTaxIdentificationNumber = "PTTaxIdentificationNumber",
+    ROPersonalNumericalCode = "ROPersonalNumericalCode",
+    RUPassportNumberDomestic = "RUPassportNumberDomestic",
+    RUPassportNumberInternational = "RUPassportNumberInternational",
+    SANationalID = "SANationalID",
+    SGNationalRegistrationIdentityCardNumber = "SGNationalRegistrationIdentityCardNumber",
+    SKPersonalNumber = "SKPersonalNumber",
+    SITaxIdentificationNumber = "SITaxIdentificationNumber",
+    SIUniqueMasterCitizenNumber = "SIUniqueMasterCitizenNumber",
+    ZAIdentificationNumber = "ZAIdentificationNumber",
+    KRResidentRegistrationNumber = "KRResidentRegistrationNumber",
+    Esdni = "ESDNI",
+    ESSocialSecurityNumber = "ESSocialSecurityNumber",
+    ESTaxIdentificationNumber = "ESTaxIdentificationNumber",
+    SQLServerConnectionString = "SQLServerConnectionString",
+    SENationalID = "SENationalID",
+    SENationalIDV2 = "SENationalIDV2",
+    SEPassportNumber = "SEPassportNumber",
+    SETaxIdentificationNumber = "SETaxIdentificationNumber",
+    SwiftCode = "SWIFTCode",
+    CHSocialSecurityNumber = "CHSocialSecurityNumber",
+    TWNationalID = "TWNationalID",
+    TWPassportNumber = "TWPassportNumber",
+    TWResidentCertificate = "TWResidentCertificate",
+    THPopulationIdentificationCode = "THPopulationIdentificationCode",
+    TRNationalIdentificationNumber = "TRNationalIdentificationNumber",
+    UKDriversLicenseNumber = "UKDriversLicenseNumber",
+    UKElectoralRollNumber = "UKElectoralRollNumber",
+    UKNationalHealthNumber = "UKNationalHealthNumber",
+    UKNationalInsuranceNumber = "UKNationalInsuranceNumber",
+    UKUniqueTaxpayerNumber = "UKUniqueTaxpayerNumber",
+    UsukPassportNumber = "USUKPassportNumber",
+    USBankAccountNumber = "USBankAccountNumber",
+    USDriversLicenseNumber = "USDriversLicenseNumber",
+    USIndividualTaxpayerIdentification = "USIndividualTaxpayerIdentification",
+    USSocialSecurityNumber = "USSocialSecurityNumber",
+    UAPassportNumberDomestic = "UAPassportNumberDomestic",
+    UAPassportNumberInternational = "UAPassportNumberInternational",
+    Organization = "Organization",
+    Email = "Email",
+    URL = "URL",
+    Age = "Age",
+    PhoneNumber = "PhoneNumber",
+    IPAddress = "IPAddress",
+    Date = "Date",
+    Person = "Person",
+    Address = "Address",
+    All = "All",
+    Default = "Default"
+}
+
+/** Known values of {@link PiiDomain} that the service accepts. */
+export declare enum KnownPiiDomain {
+    /** Indicates that entities in the Personal Health Information domain should be redacted. */
+    Phi = "phi",
+    /** Indicates that no domain is specified. */
+    None = "none"
+}
+
+/** Known values of {@link StringIndexType} that the service accepts. */
+export declare enum KnownStringIndexType {
+    /** Returned offset and length values will correspond to TextElements (Graphemes and Grapheme clusters) confirming to the Unicode 8.0.0 standard. Use this option if your application is written in .Net Framework or .Net Core and you will be using StringInfo. */
+    TextElementsV8 = "TextElements_v8",
+    /** Returned offset and length values will correspond to Unicode code points. Use this option if your application is written in a language that support Unicode, for example Python. */
+    UnicodeCodePoint = "UnicodeCodePoint",
+    /** Returned offset and length values will correspond to UTF-16 code units. Use this option if your application is written in a language that support Unicode, for example Java, JavaScript. */
+    Utf16CodeUnit = "Utf16CodeUnit"
+}
+
+/**
+ * Enum of possible error codes of a {@link TextAnalysisError}.
+ */
+export declare const KnownTextAnalysisErrorCode: {
+    InvalidRequest: KnownInnerErrorCode.InvalidRequest;
+    InvalidParameterValue: KnownInnerErrorCode.InvalidParameterValue;
+    KnowledgeBaseNotFound: KnownInnerErrorCode.KnowledgeBaseNotFound;
+    AzureCognitiveSearchNotFound: KnownInnerErrorCode.AzureCognitiveSearchNotFound;
+    AzureCognitiveSearchThrottling: KnownInnerErrorCode.AzureCognitiveSearchThrottling;
+    ExtractionFailure: KnownInnerErrorCode.ExtractionFailure;
+    InvalidRequestBodyFormat: KnownInnerErrorCode.InvalidRequestBodyFormat;
+    EmptyRequest: KnownInnerErrorCode.EmptyRequest;
+    MissingInputDocuments: KnownInnerErrorCode.MissingInputDocuments;
+    InvalidDocument: KnownInnerErrorCode.InvalidDocument;
+    ModelVersionIncorrect: KnownInnerErrorCode.ModelVersionIncorrect;
+    InvalidDocumentBatch: KnownInnerErrorCode.InvalidDocumentBatch;
+    UnsupportedLanguageCode: KnownInnerErrorCode.UnsupportedLanguageCode;
+    InvalidCountryHint: KnownInnerErrorCode.InvalidCountryHint;
+    InvalidArgument: KnownErrorCode.InvalidArgument;
+    Unauthorized: KnownErrorCode.Unauthorized;
+    Forbidden: KnownErrorCode.Forbidden;
+    NotFound: KnownErrorCode.NotFound;
+    ProjectNotFound: KnownErrorCode.ProjectNotFound;
+    OperationNotFound: KnownErrorCode.OperationNotFound;
+    AzureCognitiveSearchIndexNotFound: KnownErrorCode.AzureCognitiveSearchIndexNotFound;
+    TooManyRequests: KnownErrorCode.TooManyRequests;
+    AzureCognitiveSearchIndexLimitReached: KnownErrorCode.AzureCognitiveSearchIndexLimitReached;
+    InternalServerError: KnownErrorCode.InternalServerError;
+    ServiceUnavailable: KnownErrorCode.ServiceUnavailable;
+};
+
+/** Options for a language detection action. */
+export declare type LanguageDetectionAction = ActionPrebuilt;
+
+/**
+ * An error result from a language detection action on a single document.
+ */
+export declare type LanguageDetectionErrorResult = TextAnalysisErrorResult;
+
+/** An input to the language detection operation. This object specifies a unique document id, as well as the full text of a document and a hint indicating the document's country of origin to assist the Language predictive model in detecting the document's language. */
+export declare interface LanguageDetectionInput {
+    /** Unique, non-empty document identifier. */
+    id: string;
+    /** Full text of the input document. */
+    text: string;
+    /** A hint indicating the document's country of origin to assist the Language predictive model in detecting the document's language. */
+    countryHint?: string;
+}
+
 /**
- * A type representing how to sort sentences for the summarization extraction action.
+ * The result of a language detection action on a single document.
  */
-export declare type KnownSummarySentencesSortBy = "Offset" | "Rank";
+export declare type LanguageDetectionResult = LanguageDetectionSuccessResult | LanguageDetectionErrorResult;
 
-/** Known values of {@link WarningCode} that the service accepts. */
-export declare enum KnownWarningCode {
-    LongWordsInDocument = "LongWordsInDocument",
-    DocumentTruncated = "DocumentTruncated"
+/**
+ * The result of a language detection action on a single document,
+ * containing a prediction of what language the document is written in.
+ */
+export declare interface LanguageDetectionSuccessResult extends TextAnalysisSuccessResult {
+    /**
+     * The top detected language by confidence score.
+     */
+    readonly primaryLanguage: DetectedLanguage;
 }
 
 /** A word or phrase identified as a well-known entity within a database, including its formal (disambiguated) name and a link to the entity information within the source database. */
@@ -825,7 +1147,7 @@ export declare interface LinkedEntity {
     bingEntitySearchApiId?: string;
 }
 
-/** Details about the specific substring in a document that refers to a linked entity identified by the Text Analytics model. */
+/** Details about the specific substring in a document that refers to a linked entity identified by the Language model. */
 export declare interface Match {
     /** If a well known item is recognized, a decimal number denoting the confidence level between 0 and 1 will be returned. */
     confidenceScore: number;
@@ -837,31 +1159,8 @@ export declare interface Match {
     length: number;
 }
 
-/**
- * Metadata information for an analysis poller operation.
- */
-export declare interface OperationMetadata {
-    /**
-     * The date and time the operation was created.
-     */
-    createdOn: Date;
-    /**
-     * The date and time when the operation results will expire on the server.
-     */
-    expiresOn?: Date;
-    /**
-     * The operation id.
-     */
-    operationId: string;
-    /**
-     * The time the operation status was last updated.
-     */
-    lastModifiedOn: Date;
-    /**
-     * The current status of the operation.
-     */
-    status: TextAnalyticsOperationStatus;
-}
+/** Defines values for OperationStatus. */
+export declare type OperationStatus = "notStarted" | "running" | "succeeded" | "partiallySucceeded" | "failed" | "cancelled" | "cancelling";
 
 /**
  * A mined opinion object represents an opinion we've extracted from a sentence.
@@ -872,58 +1171,17 @@ export declare interface Opinion {
     /**
      * The target of a product/service that this assessment is about.
      */
-    target: TargetSentiment;
+    readonly target: TargetSentiment;
     /**
      * The actual assessments of the target.
      */
-    assessments: AssessmentSentiment[];
-}
-
-/**
- * The results of an analyze actions operation represented as a paged iterator that
- * iterates over the results of the requested actions.
- */
-export declare interface PagedAnalyzeActionsResult extends PagedAsyncIterableAnalyzeActionsResult {
-}
-
-/**
- * The results of a healthcare operation represented as a paged iterator that can
- * either iterate over the results on a document-by-document basis or, by
- * byPage(), can iterate over pages of documents.
- */
-export declare interface PagedAnalyzeHealthcareEntitiesResult extends PagedAsyncIterableAnalyzeHealthcareEntitiesResult {
-    /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
-     */
-    statistics?: TextDocumentBatchStatistics;
-    /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
-     */
-    modelVersion: string;
+    readonly assessments: AssessmentSentiment[];
 }
 
 /**
- * The results of an analyze Actions operation represented as a paged iterator that
- * iterates over the results of the requested actions.
- */
-export declare type PagedAsyncIterableAnalyzeActionsResult = PagedAsyncIterableIterator<AnalyzeActionsResult, AnalyzeActionsResult>;
-
-/**
- * The results of a healthcare operation represented as a paged iterator that can
- * either iterate over the results on a document-by-document basis or, by
- * byPage(), can iterate over pages of documents.
- */
-export declare type PagedAsyncIterableAnalyzeHealthcareEntitiesResult = PagedAsyncIterableIterator<AnalyzeHealthcareEntitiesResult, AnalyzeHealthcareEntitiesResultArray>;
-
-/**
- * An entity from PII recognition with information about the kind of PII
- * encountered.
+ * Paged results of the {@link TextAnalysisClient.beginAnalyzeBatch} operation.
  */
-export declare interface PiiEntity extends Entity {
-}
+export declare type PagedAnalyzeBatchResult = PagedAsyncIterableIterator<AnalyzeBatchResult>;
 
 /**
  * Defines values for PiiCategory. \
@@ -1104,395 +1362,271 @@ export declare interface PiiEntity extends Entity {
  * **All** \
  * **Default**
  */
-export declare type PiiEntityCategory = string;
+export declare type PiiCategory = string;
 
 /**
- * The types of PII domains the user can choose from.
+ * Defines values for PiiDomain. \
+ * {@link KnownPiiDomain} can be used interchangeably with PiiDomain,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **phi**: Indicates that entities in the Personal Health Information domain should be redacted. \
+ * **none**: Indicates that no domain is specified.
  */
-export declare enum PiiEntityDomain {
+export declare type PiiDomain = string;
+
+/** Options for a Pii entity recognition action. */
+export declare type PiiEntityRecognitionAction = ActionPrebuilt & {
     /**
-     * @see {@link https://aka.ms/tanerpii} for more information.
+     * Filters entities to ones only included in the specified domain (e.g., if set to `Phi`, only entities in the Protected Healthcare Information domain will be returned). For a list of possible domains, see {@link PiiDomain}.
+     *
+     * See {@link https://aka.ms/tanerpii the service documentation} for more information.
      */
-    PROTECTED_HEALTH_INFORMATION = "PHI"
-}
-
-/**
- * Options for an entities recognition action.
- */
-export declare interface RecognizeCategorizedEntitiesAction extends TextAnalyticsAction {
+    domainFilter?: PiiDomain;
+    /** Filters entities to ones only included in the specified array of categories. For a list of possible categories, see {@link KnownPiiCategory} */
+    categoriesFilter?: PiiCategory[];
     /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
      * The default is the JavaScript's default which is "Utf16CodeUnit".
      */
     stringIndexType?: StringIndexType;
+};
+
+/** Options for a pii entity recognition batch action. */
+export declare interface PiiEntityRecognitionBatchAction extends AnalyzeBatchActionCommon, PiiEntityRecognitionAction {
     /**
-     * If set to true, you opt-out of having your text input logged for troubleshooting. By default, Text Analytics
-     * logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this parameter to true,
-     * disables input logging and may limit our ability to remediate issues that occur.
+     * The kind of the action.
      */
-    disableServiceLogs?: boolean;
+    kind: "PiiEntityRecognition";
 }
 
 /**
- * The error of a recognize categorized entities action.
+ * The result of a pii entity recognition batch action.
+ */
+export declare type PiiEntityRecognitionBatchResult = ActionMetadata & BatchActionResult<PiiEntityRecognitionResult, "PiiEntityRecognition">;
+
+/**
+ * An error result from a pii entity recognition action on a single document.
  */
-export declare type RecognizeCategorizedEntitiesActionErrorResult = TextAnalyticsActionErrorResult;
+export declare type PiiEntityRecognitionErrorResult = TextAnalysisErrorResult;
 
 /**
- * The result of a recognize categorized entities action.
+ * The result of an entity recognition action on a single document.
  */
-export declare type RecognizeCategorizedEntitiesActionResult = RecognizeCategorizedEntitiesActionSuccessResult | RecognizeCategorizedEntitiesActionErrorResult;
+export declare type PiiEntityRecognitionResult = PiiEntityRecognitionSuccessResult | PiiEntityRecognitionErrorResult;
 
 /**
- * The results of a succeeded recognize categorized entities action.
+ * The result of a pii entity recognition action on a single document,
+ * containing the collection of {@link Entity} objects identified in that
+ * document.
  */
-export declare interface RecognizeCategorizedEntitiesActionSuccessResult extends TextAnalyticsActionSuccessState {
+export declare interface PiiEntityRecognitionSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * Array of the results for each categorized entities recognition action.
+     * The collection of entities identified in the input document.
+     */
+    readonly entities: Entity[];
+    /**
+     * The text redacted.
      */
-    results: RecognizeCategorizedEntitiesResultArray;
+    readonly redactedText: string;
 }
 
 /**
- * An error result from the recognize entities operation on a single document.
+ * Defines values for RelationType. \
+ * {@link KnownRelationType} can be used interchangeably with RelationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Abbreviation** \
+ * **DirectionOfBodyStructure** \
+ * **DirectionOfCondition** \
+ * **DirectionOfExamination** \
+ * **DirectionOfTreatment** \
+ * **DosageOfMedication** \
+ * **FormOfMedication** \
+ * **FrequencyOfMedication** \
+ * **FrequencyOfTreatment** \
+ * **QualifierOfCondition** \
+ * **RelationOfExamination** \
+ * **RouteOfMedication** \
+ * **TimeOfCondition** \
+ * **TimeOfEvent** \
+ * **TimeOfExamination** \
+ * **TimeOfMedication** \
+ * **TimeOfTreatment** \
+ * **UnitOfCondition** \
+ * **UnitOfExamination** \
+ * **ValueOfCondition** \
+ * **ValueOfExamination**
  */
-export declare type RecognizeCategorizedEntitiesErrorResult = TextAnalyticsErrorResult;
+export declare type RelationType = string;
 
 /**
- * Options for the recognize entities operation.
+ * Options for the begin analyze actions operation.
  */
-export declare interface RecognizeCategorizedEntitiesOptions extends TextAnalyticsOperationOptions {
+export declare interface RestoreAnalyzeBatchPollerOptions extends TextAnalysisOperationOptions {
     /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     * Time delay between poll requests, in milliseconds.
      */
-    stringIndexType?: StringIndexType;
+    updateIntervalInMs?: number;
 }
 
 /**
- * The result of the recognize entities operation on a single document.
- */
-export declare type RecognizeCategorizedEntitiesResult = RecognizeCategorizedEntitiesSuccessResult | RecognizeCategorizedEntitiesErrorResult;
-
-/**
- * Array of `RecognizeCategorizedEntitiesResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
+ * The predicted sentiment for a given span of text. For more information
+ * regarding text sentiment, see {@link https://docs.microsoft.com//azure/cognitive-services/language-service/sentiment-opinion-mining/overview}.
  */
-export declare interface RecognizeCategorizedEntitiesResultArray extends Array<RecognizeCategorizedEntitiesResult> {
+export declare interface SentenceSentiment {
     /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * The sentence text.
      */
-    statistics?: TextDocumentBatchStatistics;
+    readonly text: string;
     /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
+     * The predicted Sentiment for the sentence. For a list of possible values,
+     * see {@link SentenceSentimentLabel}
      */
-    modelVersion: string;
-}
-
-/**
- * The result of the recognize entities operation on a single document, containing the collection of
- * `Entity` objects identified in that document.
- */
-export declare interface RecognizeCategorizedEntitiesSuccessResult extends TextAnalyticsSuccessResult {
+    readonly sentiment: SentenceSentimentLabel;
     /**
-     * The collection of entities identified in the input document.
+     * The sentiment confidence score between 0 and 1 for the sentence for all
+     * classes.
      */
-    readonly entities: CategorizedEntity[];
-}
-
-/**
- * Options for an entities linking action.
- */
-export declare interface RecognizeLinkedEntitiesAction extends TextAnalyticsAction {
+    readonly confidenceScores: SentimentConfidenceScores;
     /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     * The sentence text offset from the start of the document.
      */
-    stringIndexType?: StringIndexType;
+    readonly offset: number;
     /**
-     * If set to true, you opt-out of having your text input logged for troubleshooting. By default, Text Analytics
-     * logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this parameter to true,
-     * disables input logging and may limit our ability to remediate issues that occur.
+     * The length of the sentence text.
      */
-    disableServiceLogs?: boolean;
+    readonly length: number;
+    /**
+     * The list of opinions mined from this sentence. For example in "The food is
+     * good, but the service is bad", the following two opinions will be returned:
+     * "food is good" and "service is bad".
+     *
+     * It is non-empty only returned if {@link includeOpinionMining} was set to
+     * `true`.
+     */
+    readonly opinions: Opinion[];
 }
 
-/**
- * The error of a recognize linked entities action.
- */
-export declare type RecognizeLinkedEntitiesActionErrorResult = TextAnalyticsActionErrorResult;
+/** Defines values for SentenceSentimentLabel. */
+export declare type SentenceSentimentLabel = "positive" | "neutral" | "negative";
 
-/**
- * The result of a recognize linked entities action.
- */
-export declare type RecognizeLinkedEntitiesActionResult = RecognizeLinkedEntitiesActionSuccessResult | RecognizeLinkedEntitiesActionErrorResult;
+/** Options for a sentiment analysis action. */
+export declare type SentimentAnalysisAction = ActionPrebuilt & {
+    /** Enables performing opinion mining on the input documents, a more  granular analysis around the aspects of a product or service (also known as aspect-based sentiment analysis). If set to true, {@link SentenceSentiment.opinions} will contain the results of this analysis. See {@link https://docs.microsoft.com/azure/cognitive-services/language-service/sentiment-opinion-mining/overview#opinion-mining the service documentation} for more information. */
+    includeOpinionMining?: boolean;
+    /**
+     * Specifies the measurement unit used to calculate the offset and length properties. For a list of possible values, see {@link KnownStringIndexType}.
+     *
+     * The default is the JavaScript's default which is "Utf16CodeUnit".
+     */
+    stringIndexType?: StringIndexType;
+};
 
-/**
- * The results of a succeeded recognize linked entities action.
- */
-export declare interface RecognizeLinkedEntitiesActionSuccessResult extends TextAnalyticsActionSuccessState {
+/** Options for a sentiment analysis batch action. */
+export declare interface SentimentAnalysisBatchAction extends AnalyzeBatchActionCommon, SentimentAnalysisAction {
     /**
-     * Array of the results for each linked entities recognition action.
+     * The kind of the action.
      */
-    results: RecognizeLinkedEntitiesResultArray;
+    kind: "SentimentAnalysis";
 }
 
 /**
- * An error result from the recognize linked entities operation on a single document.
+ * The result of a sentiment analysis batch action.
  */
-export declare type RecognizeLinkedEntitiesErrorResult = TextAnalyticsErrorResult;
+export declare type SentimentAnalysisBatchResult = ActionMetadata & BatchActionResult<SentimentAnalysisResult, "SentimentAnalysis">;
 
 /**
- * Options for the recognize linked entities operation.
+ * An error result from a sentiment analysis action on a single document.
  */
-export declare interface RecognizeLinkedEntitiesOptions extends TextAnalyticsOperationOptions {
-    /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
-     */
-    stringIndexType?: StringIndexType;
-}
+export declare type SentimentAnalysisErrorResult = TextAnalysisErrorResult;
 
 /**
- * The result of the recognize linked entities operation on a single document.
+ * The result of a sentiment analysis action on a single document.
  */
-export declare type RecognizeLinkedEntitiesResult = RecognizeLinkedEntitiesSuccessResult | RecognizeLinkedEntitiesErrorResult;
+export declare type SentimentAnalysisResult = SentimentAnalysisSuccessResult | SentimentAnalysisErrorResult;
 
 /**
- * Array of `RecognizeLinkedEntitiesResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
+ * The result of a sentiment analysis action on a single document,
+ * containing the predicted sentiment for each sentence as well as for the full
+ * document.
  */
-export declare interface RecognizeLinkedEntitiesResultArray extends Array<RecognizeLinkedEntitiesResult> {
+export declare interface SentimentAnalysisSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * Predicted sentiment for document. For a list of possible values, see {@link DocumentSentimentLabel}
      */
-    statistics?: TextDocumentBatchStatistics;
+    readonly sentiment: DocumentSentimentLabel;
     /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
+     * Document level sentiment confidence scores between 0 and 1 for each
+     * sentiment class.
      */
-    modelVersion: string;
-}
-
-/**
- * The result of the recognize linked entities operation on a single document,
- * containing a collection of the `LinkedEntity` objects identified in that document.
- */
-export declare interface RecognizeLinkedEntitiesSuccessResult extends TextAnalyticsSuccessResult {
-    /**
-     * The collection of entities identified in the input document.
-     */
-    readonly entities: LinkedEntity[];
-}
-
-/**
- * Options for a Pii entities recognition action.
- */
-export declare interface RecognizePiiEntitiesAction extends TextAnalyticsAction {
-    /**
-     * Filters entities to ones only included in the specified domain (e.g., if
-     * set to 'PHI', entities in the Protected Healthcare Information domain will
-     * only be returned). @see {@link https://aka.ms/tanerpii} for more information.
-     */
-    domainFilter?: PiiEntityDomain;
-    /**
-     * Filters entities to ones only included in the specified array of categories
-     */
-    categoriesFilter?: PiiEntityCategory[];
-    /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
-     */
-    stringIndexType?: StringIndexType;
+    readonly confidenceScores: SentimentConfidenceScores;
     /**
-     * If set to false, you opt-in to have your text input logged for troubleshooting. By default, Text Analytics
-     * will not log your input text for pii entities recognition. Setting this parameter to false,
-     * enables input logging.
-     */
-    disableServiceLogs?: boolean;
-}
-
-/**
- * The error of a recognize pii entities action.
- */
-export declare type RecognizePiiEntitiesActionErrorResult = TextAnalyticsActionErrorResult;
-
-/**
- * The result of a recognize pii entities action.
- */
-export declare type RecognizePiiEntitiesActionResult = RecognizePiiEntitiesActionSuccessResult | RecognizePiiEntitiesActionErrorResult;
-
-/**
- * The results of a succeeded recognize pii entities action.
- */
-export declare interface RecognizePiiEntitiesActionSuccessResult extends TextAnalyticsActionSuccessState {
-    /**
-     * Array of the results for each pii entities recognition action.
+     * The predicted sentiment for each sentence in the corresponding document.
      */
-    results: RecognizePiiEntitiesResultArray;
+    readonly sentences: SentenceSentiment[];
 }
 
-/**
- * An error result from the recognize entities operation on a single document.
- */
-export declare type RecognizePiiEntitiesErrorResult = TextAnalyticsErrorResult;
-
-/**
- * Options for the recognize PII entities operation.
- */
-export declare interface RecognizePiiEntitiesOptions extends TextAnalyticsOperationOptions {
-    /**
-     * Filters entities to ones only included in the specified domain (e.g., if
-     * set to 'PHI', entities in the Protected Healthcare Information domain will
-     * only be returned). @see {@link https://aka.ms/tanerpii} for more information.
-     */
-    domainFilter?: PiiEntityDomain;
-    /**
-     * Specifies the measurement unit used to calculate the offset and length properties.
-     * Possible units are "TextElements_v8", "UnicodeCodePoint", and "Utf16CodeUnit".
-     * The default is the JavaScript's default which is "Utf16CodeUnit".
-     */
-    stringIndexType?: StringIndexType;
-    /**
-     * Filters entities to ones only included in the specified array of categories
-     */
-    categoriesFilter?: PiiEntityCategory[];
+/** Represents the confidence scores between 0 and 1 across all sentiment classes: positive, neutral, negative. */
+export declare interface SentimentConfidenceScores {
+    positive: number;
+    neutral: number;
+    negative: number;
 }
 
 /**
- * The result of the recognize entities operation on a single document.
+ * Defines values for StringIndexType. \
+ * {@link KnownStringIndexType} can be used interchangeably with StringIndexType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **TextElements_v8**: Returned offset and length values will correspond to TextElements (Graphemes and Grapheme clusters) confirming to the Unicode 8.0.0 standard. Use this option if your application is written in .Net Framework or .Net Core and you will be using StringInfo. \
+ * **UnicodeCodePoint**: Returned offset and length values will correspond to Unicode code points. Use this option if your application is written in a language that support Unicode, for example Python. \
+ * **Utf16CodeUnit**: Returned offset and length values will correspond to UTF-16 code units. Use this option if your application is written in a language that support Unicode, for example Java, JavaScript.
  */
-export declare type RecognizePiiEntitiesResult = RecognizePiiEntitiesSuccessResult | RecognizePiiEntitiesErrorResult;
+export declare type StringIndexType = string;
 
 /**
- * Collection of `RecognizePiiEntitiesResult` objects corresponding to a batch of input documents, and
- * annotated with information about the batch operation.
+ * An error result from the extract summary operation on a single document.
  */
-export declare interface RecognizePiiEntitiesResultArray extends Array<RecognizePiiEntitiesResult> {
-    /**
-     * Statistics about the input document batch and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
-     */
-    statistics?: TextDocumentBatchStatistics;
-    /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
-     */
-    modelVersion: string;
-}
+export declare type SummarizationExtractionErrorResult = TextAnalysisErrorResult;
 
 /**
- * The result of the recognize entities operation on a single document, containing the collection of
- * `Entity` objects identified in that document.
+ * The result of the extract summary operation on a single document.
  */
-export declare interface RecognizePiiEntitiesSuccessResult extends TextAnalyticsSuccessResult {
-    /**
-     * The collection of entities identified in the input document.
-     */
-    readonly entities: PiiEntity[];
-    /**
-     * The text redacted.
-     */
-    redactedText: string;
-}
-
-export declare interface SentenceAssessment {
-    /** Assessment sentiment in the sentence. */
-    sentiment: TokenSentimentValue;
-    /** Assessment sentiment confidence scores in the sentence. */
-    confidenceScores: TargetConfidenceScoreLabel;
-    /** The assessment offset from the start of the sentence. */
-    offset: number;
-    /** The length of the assessment. */
-    length: number;
-    /** The assessment text detected. */
-    text: string;
-    /** The indicator representing if the assessment is negated. */
-    isNegated: boolean;
-}
+export declare type SummarizationExtractionResult = SummarizationExtractionSuccessResult | SummarizationExtractionErrorResult;
 
 /**
- * The predicted sentiment for a given span of text. For more information regarding text sentiment, see https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/how-tos/text-analytics-how-to-sentiment-analysis.
+ * The result of the summarization extraction action on a single document,
+ * containing a collection of the summary identified in that document.
  */
-export declare interface SentenceSentiment {
-    /**
-     * The sentence text.
-     */
-    text: string;
-    /**
-     * The predicted Sentiment for the sentence.
-     */
-    sentiment: SentenceSentimentLabel;
-    /**
-     * The sentiment confidence score between 0 and 1 for the sentence for all classes.
-     */
-    confidenceScores: SentimentConfidenceScores;
-    /**
-     * The sentence text offset from the start of the document.
-     */
-    offset: number;
-    /**
-     * The length of the sentence text.
-     */
-    length: number;
+export declare interface SummarizationExtractionSuccessResult extends TextAnalysisSuccessResult {
     /**
-     * The list of opinions mined from this sentence. For example in "The food is
-     * good, but the service is bad", we would mine these two opinions "food is
-     * good", "service is bad". Only returned if `includeOpinionMining` is set to
-     * True in the call to `analyzeSentiment`.
+     * A list of sentences composing a summary of the input document.
      */
-    opinions: Opinion[];
+    readonly sentences: SummarySentence[];
 }
 
-/** Defines values for SentenceSentimentLabel. */
-export declare type SentenceSentimentLabel = "positive" | "neutral" | "negative";
-
-/** Represents the confidence scores between 0 and 1 across all sentiment classes: positive, neutral, negative. */
-export declare interface SentimentConfidenceScores {
-    positive: number;
-    neutral: number;
-    negative: number;
-}
-
-/**
- * Measurement units that can used to calculate the offset and length properties.
- */
-export declare type StringIndexType = "TextElement_v8" | "UnicodeCodePoint" | "Utf16CodeUnit";
-
-/**
- * An extracted sentence as part of the summary of a document.
- */
+/** A sentence that is part of the extracted summary. */
 export declare interface SummarySentence {
     /** The extracted sentence text. */
     text: string;
     /** A double value representing the relevance of the sentence within the summary. Higher values indicate higher importance. */
     rankScore: number;
-    /** The sentence offset from the start of the document, based on the value of the stringIndexType parameter. */
+    /** The sentence offset from the start of the document, based on the value of the parameter StringIndexType. */
     offset: number;
     /** The length of the sentence. */
     length: number;
 }
 
 /** Represents the confidence scores across all sentiment classes: positive, neutral, negative. */
-export declare interface TargetConfidenceScoreLabel {
+export declare interface TargetConfidenceScores {
     positive: number;
     negative: number;
 }
 
 /**
  * TargetSentiment contains the predicted sentiment, confidence scores and other
- * information about an target of a product. A target of a product/service is a
+ * information about a target of a product. A target of a product/service is a
  * key component of that product/service. For example in "The food at Hotel Foo
  * is good", "food" is a target of "Hotel Foo".
  */
@@ -1501,335 +1635,510 @@ export declare interface TargetSentiment {
      * The sentiment confidence score between 0 and 1 for the target for
      * 'positive' and 'negative' labels.
      */
-    confidenceScores: TargetConfidenceScoreLabel;
+    readonly confidenceScores: TargetConfidenceScores;
     /**
-     * The predicted Sentiment for the Target. Possible values include 'positive',
-     * 'mixed', and 'negative'.
+     * The predicted Sentiment for the Target. For a list of possible values,
+     * see {@link TokenSentimentLabel}
      */
-    sentiment: TokenSentimentValue;
+    readonly sentiment: TokenSentimentLabel;
     /**
      * The target text.
      */
-    text: string;
+    readonly text: string;
     /**
      * The Target text offset from the start of the sentence.
      */
-    offset: number;
+    readonly offset: number;
     /**
      * The length of the Target text.
      */
-    length: number;
+    readonly length: number;
 }
 
 /**
- * The type of a text analytics action.
- */
-export declare interface TextAnalyticsAction {
-    /**
-     * The version of the text analytics model used by this operation on this
-     * batch of input documents.
-     */
-    modelVersion?: string;
-    /**
-     * The preferred name for this action.
-     */
-    actionName?: string;
-}
-
-/**
- * The error of an analyze batch action.
- */
-export declare interface TextAnalyticsActionErrorResult {
-    /**
-     * When this action was completed by the service.
-     */
-    readonly failedOn: Date;
-    /**
-     * The Error for this action result.
-     */
-    readonly error: TextAnalyticsError;
-}
-
-/**
- * Description of collection of actions for the analyze API to perform on input documents. However, currently, the service can accept up to one action only per action type.
+ * A client for interacting with the text analysis features in Azure Cognitive
+ * Language Service.
+ *
+ * The client needs the endpoint of a Language resource and an authentication
+ * method such as an API key or AAD. The API key and endpoint can be found in
+ * the Language resource page in the Azure portal. They will be located in the
+ * resource's Keys and Endpoint page, under Resource Management.
+ *
+ * ### Examples for authentication:
+ *
+ * #### API Key
+ *
+ * ```js
+ * import { TextAnalysisClient, AzureKeyCredential } from "@azure/ai-text-analytics";
+ *
+ * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
+ * const credential = new AzureKeyCredential("<api key>");
+ *
+ * const client = new TextAnalysisClient(endpoint, credential);
+ * ```
+ *
+ * #### Azure Active Directory
+ *
+ * See the [`@azure/identity`](https://npmjs.com/package/\@azure/identity)
+ * package for more information about authenticating with Azure Active Directory.
+ *
+ * ```js
+ * import { TextAnalysisClient } from "@azure/ai-text-analytics";
+ * import { DefaultAzureCredential } from "@azure/identity";
+ *
+ * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
+ * const credential = new DefaultAzureCredential();
+ *
+ * const client = new TextAnalysisClient(endpoint, credential);
+ * ```
  */
-export declare interface TextAnalyticsActions {
+export declare class TextAnalysisClient {
+    private readonly _client;
+    private readonly _tracing;
+    private readonly defaultCountryHint;
+    private readonly defaultLanguage;
     /**
-     * A collection of descriptions of entities recognition actions. However, currently, the service can accept up to one action only for `recognizeEntities`.
-     */
-    recognizeEntitiesActions?: RecognizeCategorizedEntitiesAction[];
-    /**
-     * A collection of descriptions of Pii entities recognition actions. However, currently, the service can accept up to one action only for `recognizePiiEntities`.
-     */
-    recognizePiiEntitiesActions?: RecognizePiiEntitiesAction[];
-    /**
-     * A collection of descriptions of key phrases recognition actions. However, currently, the service can accept up to one action only for `extractKeyPhrases`.
-     */
-    extractKeyPhrasesActions?: ExtractKeyPhrasesAction[];
-    /**
-     * A collection of descriptions of entities linking actions. However, currently, the service can accept up to one action only for `recognizeLinkedEntities`.
-     */
-    recognizeLinkedEntitiesActions?: RecognizeLinkedEntitiesAction[];
-    /**
-     * A collection of descriptions of sentiment analysis actions. However, currently, the service can accept up to one action only for `analyzeSentiment`.
+     * Creates an instance of TextAnalysisClient with the endpoint of a Language
+     * resource and an authentication method such as an API key or AAD.
+     *
+     * The API key and endpoint can be found in the Language resource page in the
+     * Azure portal. They will be located in the resource's Keys and Endpoint page,
+     * under Resource Management.
+     *
+     * ### Example
+     *
+     * ```js
+     * import { TextAnalysisClient, AzureKeyCredential } from "@azure/ai-text-analytics";
+     *
+     * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
+     * const credential = new AzureKeyCredential("<api key>");
+     *
+     * const client = new TextAnalysisClient(endpoint, credential);
+     * ```
+     *
+     * @param endpointUrl - The URL to the endpoint of a Cognitive Language Service resource
+     * @param credential - Key credential to be used to authenticate requests to the service.
+     * @param options - Used to configure the TextAnalytics client.
      */
-    analyzeSentimentActions?: AnalyzeSentimentAction[];
+    constructor(endpointUrl: string, credential: KeyCredential, options?: TextAnalysisClientOptions);
     /**
-     * A collection of descriptions of summarization extraction actions. However, currently, the service can accept up to one action only for `extractSummary`.
+     * Creates an instance of TextAnalysisClient with the endpoint of a Language
+     * resource and an authentication method such as an API key or AAD.
+     *
+     * The API key and endpoint can be found in the Language resource page in the
+     * Azure portal. They will be located in the resource's Keys and Endpoint page,
+     * under Resource Management.
+     *
+     * ### Example
+     *
+     * See the [`@azure/identity`](https://npmjs.com/package/\@azure/identity)
+     * package for more information about authenticating with Azure Active Directory.
+     *
+     * ```js
+     * import { TextAnalysisClient } from "@azure/ai-text-analytics";
+     * import { DefaultAzureCredential } from "@azure/identity";
+     *
+     * const endpoint = "https://<resource name>.cognitiveservices.azure.com";
+     * const credential = new DefaultAzureCredential();
+     *
+     * const client = new TextAnalysisClient(endpoint, credential);
+     * ```
+     *
+     * @param endpointUrl - The URL to the endpoint of a Cognitive Language Service resource
+     * @param credential - Token credential to be used to authenticate requests to the service.
+     * @param options - Used to configure the TextAnalytics client.
      */
-    extractSummaryActions?: ExtractSummaryAction[];
-}
-
-/**
- * The state of a succeeded action.
- */
-export declare interface TextAnalyticsActionSuccessState {
+    constructor(endpointUrl: string, credential: TokenCredential, options?: TextAnalysisClientOptions);
     /**
-     * When this action was completed by the service.
+     * Runs a predictive model to determine the language that the passed-in
+     * input strings are written in, and returns, for each one, the detected
+     * language as well as a score indicating the model's confidence that the
+     * inferred language is correct.  Scores close to 1 indicate high certainty in
+     * the result.  120 languages are supported.
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
+     *
+     * ### Examples
+     *
+     * #### Language detection
+     *
+     * ```js
+     * const documents = [<input strings>];
+     * const countryHint = "us";
+     * const results = await client.analyze("LanguageDetection", documents, countryHint);
+     *
+     * for (let i = 0; i < results.length; i++) {
+     *   const result = results[i];
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { name, confidenceScore, iso6391Name } = result.primaryLanguage;
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/language-detection/overview}
+     * for more information on language detection.
+     *
+     * @param actionName - the name of the action to be performed on the input
+     *   documents, see ${@link AnalyzeActionName}
+     * @param documents - the input documents to be analyzed
+     * @param options - optional action parameters and settings for the operation
+     *
+     * @returns an array of results where each element contains the primary language
+     *   for the corresponding input document.
      */
-    readonly completedOn: Date;
+    analyze<ActionName extends "LanguageDetection">(actionName: ActionName, documents: LanguageDetectionInput[], options?: AnalyzeActionParameters<ActionName> & TextAnalysisOperationOptions): Promise<AnalyzeResult<ActionName>>;
     /**
-     * Discriminant to determine if that this is an error result.
+     * Runs a predictive model to determine the language that the passed-in
+     * input strings are written in, and returns, for each one, the detected
+     * language as well as a score indicating the model's confidence that the
+     * inferred language is correct.  Scores close to 1 indicate high certainty in
+     * the result.  120 languages are supported.
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
+     *
+     * ### Examples
+     *
+     * #### Language detection
+     *
+     * ```js
+     * const documents = [<input strings>];
+     * const countryHint = "us";
+     * const results = await client.analyze("LanguageDetection", documents, countryHint);
+     *
+     * for (const result of results) {
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { name, confidenceScore, iso6391Name } = result.primaryLanguage;
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/language-detection/overview}
+     * for more information on language detection.
+     *
+     * @param actionName - the name of the action to be performed on the input
+     *   documents, see ${@link AnalyzeActionName}
+     * @param documents - the input documents to be analyzed
+     * @param countryHint - Indicates the country of origin for all of
+     *   the input strings to assist the model in predicting the language they are
+     *   written in.  If unspecified, this value will be set to the default
+     *   country hint in `TextAnalysisClientOptions`. If set to an empty string,
+     *   or the string "none", the service will apply a model where the country is
+     *   explicitly unset. The same country hint is applied to all strings in the
+     *   input collection.
+     * @param options - optional action parameters and settings for the operation
+     *
+     * @returns an array of results where each element contains the primary language
+     *   for the corresponding input document.
      */
-    readonly error?: undefined;
-}
-
-/**
- * Client class for interacting with Azure Text Analytics.
- */
-export declare class TextAnalyticsClient {
+    analyze<ActionName extends "LanguageDetection">(actionName: ActionName, documents: string[], countryHint?: string, options?: AnalyzeActionParameters<ActionName> & TextAnalysisOperationOptions): Promise<AnalyzeResult<ActionName>>;
     /**
-     * The URL to the TextAnalytics endpoint
+     * Runs a predictive model to perform the action of choice on the input
+     * documents. See ${@link AnalyzeActionName} for a list of supported
+     * actions.
+     *
+     * The layout of each item in the results array depends on the action chosen.
+     * For example, each PIIEntityRecognition document result consists of both
+     * `entities` and `redactedText` where the former is a list of all Pii entities
+     * in the text and the latter is the original text after all such Pii entities
+     * have been redacted from it.
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
+     *
+     * ### Examples
+     *
+     * #### Opinion mining
+     *
+     * ```js
+     * const documents = [{
+     *  id: "1",
+     *  text: "The food and service aren't the best",
+     *  language: "en"
+     * }];
+     * const results = await client.analyze("SentimentAnalysis", documents, {
+     *   includeOpinionMining: true,
+     * });
+     *
+     * for (const result of results) {
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { sentiment, confidenceScores, sentences } = result;
+     *     for (const { sentiment, confidenceScores, opinions } of sentences) {
+     *       for (const { target, assessments } of opinions) {
+     *         const { text, sentiment, confidenceScores } = target;
+     *         for (const { text, sentiment } of assessments) {
+     *           // Do something
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/sentiment-opinion-mining/overview}
+     * for more information on opinion mining.
+     *
+     * #### Personally identifiable information
+     *
+     * ```js
+     * const documents = [<input documents>];
+     * const categoriesFilter = [KnownPiiCategory.USSocialSecurityNumber];
+     * const domainFilter = KnownPiiDomain.Phi;
+     * const results = await client.analyze("PiiEntityRecognition", documents, {
+     *   domainFilter, categoriesFilter
+     * });
+     *
+     * for (const result of results) {
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { entities, redactedText } = result;
+     *     for (const { text, category, confidenceScore, length, offset } of entities) {
+     *       // Do something
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/personally-identifiable-information/overview}
+     * for more information on personally identifiable information.
+     *
+     * @param actionName - the name of the action to be performed on the input
+     *   documents, see ${@link AnalyzeActionName}
+     * @param documents - the input documents to be analyzed
+     * @param options - optional action parameters and settings for the operation
+     *
+     * @returns an array of results corresponding to the input documents
      */
-    readonly endpointUrl: string;
+    analyze<ActionName extends AnalyzeActionName = AnalyzeActionName>(actionName: ActionName, documents: TextDocumentInput[], options?: AnalyzeActionParameters<ActionName> & TextAnalysisOperationOptions): Promise<AnalyzeResult<ActionName>>;
     /**
-     * The default country hint to use. Defaults to "us".
+     * Runs a predictive model to perform the action of choice on the input
+     * strings. See ${@link AnalyzeActionName} for a list of supported
+     * actions.
+     *
+     * The layout of each item in the results array depends on the action chosen.
+     * For example, each PIIEntityRecognition document result consists of both
+     * `entities` and `redactedText` where the former is a list of all Pii entities
+     * in the text and the latter is the original text after all such Pii entities
+     * have been redacted from it.
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
+     *
+     * ### Examples
+     *
+     * #### Opinion mining
+     *
+     * ```js
+     * const documents = ["The food and service aren't the best"];
+     * const results = await client.analyze("SentimentAnalysis", documents, {
+     *   includeOpinionMining: true,
+     * });
+     *
+     * for (const result of results) {
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { sentiment, confidenceScores, sentences } = result;
+     *     for (const { sentiment, confidenceScores, opinions } of sentences) {
+     *       for (const { target, assessments } of opinions) {
+     *         const { text, sentiment, confidenceScores } = target;
+     *         for (const { text, sentiment } of assessments) {
+     *           // Do something
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/sentiment-opinion-mining/overview}
+     * for more information on opinion mining.
+     *
+     * #### Personally identifiable information
+     *
+     * ```js
+     * const documents = [<input strings>];
+     * const languageHint = "en";
+     * const categoriesFilter = [KnownPiiCategory.USSocialSecurityNumber];
+     * const domainFilter = KnownPiiDomain.Phi;
+     * const results = await client.analyze("PiiEntityRecognition", documents, languageHint, {
+     *   domainFilter, categoriesFilter
+     * });
+     *
+     * for (const result of results) {
+     *   if (result.error) {
+     *     // a document has an error instead of results
+     *   } else {
+     *     const { entities, redactedText } = result;
+     *     for (const { text, category, confidenceScore, length, offset } of entities) {
+     *       // Do something
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/personally-identifiable-information/overview}
+     * for more information on personally identifiable information.
+     *
+     * @param actionName - the name of the action to be performed on the input
+     *   documents, see ${@link AnalyzeActionName}
+     * @param documents - the input documents to be analyzed
+     * @param languageCode - the code of the language that all the input strings are
+     *    written in. If unspecified, this value will be set to the default
+     *    language in `TextAnalysisClientOptions`. If set to an empty string,
+     *    the service will apply a model where the language is explicitly set to
+     *    "None". Language support varies per action, for example, more information
+     *    about the languages supported for Entity Recognition actions can be
+     *    found in {@link https://docs.microsoft.com//azure/cognitive-services/language-service/named-entity-recognition/language-support}
+     * @param options - optional action parameters and settings for the operation
+     *
+     * @returns an array of results corresponding to the input documents
      */
-    defaultCountryHint: string;
+    analyze<ActionName extends AnalyzeActionName = AnalyzeActionName>(actionName: ActionName, documents: string[], languageCode?: string, options?: AnalyzeActionParameters<ActionName> & TextAnalysisOperationOptions): Promise<AnalyzeResult<ActionName>>;
     /**
-     * The default language to use. Defaults to "en".
+     * Performs an array (batch) of actions on the input documents. Each action has
+     * a `kind` field that specifies the nature of the action. See ${@link AnalyzeBatchActionNames}
+     * for a list of supported actions. In addition to `kind`, actions could also
+     * have other parameters such as `disableServiceLogs` and `modelVersion`.
+     *
+     * The results array contains the results for those input actions where each
+     * item also has a `kind` field that specifies the type of the results.
+     *
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
+     *
+     * ### Examples
+     *
+     * #### Key phrase extraction and Pii entity recognition
+     *
+     * ```js
+     * const poller = await client.beginAnalyzeBatch(
+     *  [{ kind: "KeyPhraseExtraction" }, { kind: "PiiEntityRecognition" }],
+     *  documents
+     * );
+     * const actionResults = await poller.pollUntilDone();
+     *
+     * for await (const actionResult of actionResults) {
+     *  if (actionResult.error) {
+     *    throw new Error(`Unexpected error`);
+     *  }
+     *  switch (actionResult.kind) {
+     *    case "KeyPhraseExtraction": {
+     *      for (const doc of actionResult.results) {
+     *        // do something
+     *      }
+     *      break;
+     *    }
+     *    case "PiiEntityRecognition": {
+     *      for (const doc of actionResult.results) {
+     *        // do something
+     *      }
+     *      break;
+     *    }
+     *  }
+     * }
+     * ```
+     *
+     * @param actions - an array of actions that will be run on the input documents
+     * @param documents - the input documents to be analyzed
+     * @param languageCode - the code of the language that all the input strings are
+     *    written in. If unspecified, this value will be set to the default
+     *    language in `TextAnalysisClientOptions`. If set to an empty string,
+     *    the service will apply a model where the language is explicitly set to
+     *    "None". Language support varies per action, for example, more information
+     *    about the languages supported for Entity Recognition actions can be
+     *    found in {@link https://docs.microsoft.com//azure/cognitive-services/language-service/named-entity-recognition/language-support}
+     * @param options - optional settings for the operation
+     *
+     * @returns an array of results corresponding to the input actions
      */
-    defaultLanguage: string;
-    /* Excluded from this release type: client */
+    beginAnalyzeBatch(actions: AnalyzeBatchAction[], documents: string[], languageCode?: string, options?: BeginAnalyzeBatchOptions): Promise<AnalyzeBatchPoller>;
     /**
-     * Creates an instance of TextAnalyticsClient.
+     * Performs an array (batch) of actions on the input documents. Each action has
+     * a `kind` field that specifies the nature of the action. See ${@link AnalyzeBatchActionNames}
+     * for a list of supported actions. In addition to `kind`, actions could also
+     * have other parameters such as `disableServiceLogs` and `modelVersion`.
+     *
+     * The results array contains the results for those input actions where each
+     * item also has a `kind` field that specifies the type of the results.
      *
-     * Example usage:
-     * ```ts
-     * import { TextAnalyticsClient, AzureKeyCredential } from "@azure/ai-text-analytics";
+     * See {@link https://docs.microsoft.com//azure/cognitive-services/language-service/concepts/data-limits}
+     * for data limits.
      *
-     * const client = new TextAnalyticsClient(
-     *    "<service endpoint>",
-     *    new AzureKeyCredential("<api key>")
+     * ### Examples
+     *
+     * #### Keyphrase extraction and Pii entity recognition
+     *
+     * ```js
+     * const poller = await client.beginAnalyzeBatch(
+     *  [{ kind: "KeyPhraseExtraction" }, { kind: "PiiEntityRecognition" }],
+     *  documents
      * );
+     * const actionResults = await poller.pollUntilDone();
+     *
+     * for await (const actionResult of actionResults) {
+     *  if (actionResult.error) {
+     *    throw new Error(`Unexpected error`);
+     *  }
+     *  switch (actionResult.kind) {
+     *    case "KeyPhraseExtraction": {
+     *      for (const doc of actionResult.results) {
+     *        // do something
+     *      }
+     *      break;
+     *    }
+     *    case "PiiEntityRecognition": {
+     *      for (const doc of actionResult.results) {
+     *        // do something
+     *      }
+     *      break;
+     *    }
+     *  }
+     * }
      * ```
-     * @param endpointUrl - The URL to the TextAnalytics endpoint
-     * @param credential - Used to authenticate requests to the service.
-     * @param options - Used to configure the TextAnalytics client.
+     *
+     * @param actions - an array of actions that will be run on the input documents
+     * @param documents - the input documents to be analyzed
+     * @param options - optional settings for the operation
+     *
+     * @returns an array of results corresponding to the input actions
      */
-    constructor(endpointUrl: string, credential: TokenCredential | KeyCredential, options?: TextAnalyticsClientOptions);
+    beginAnalyzeBatch(actions: AnalyzeBatchAction[], documents: TextDocumentInput[], options?: BeginAnalyzeBatchOptions): Promise<AnalyzeBatchPoller>;
     /**
-     * Runs a predictive model to determine the language that the passed-in
-     * input strings are written in, and returns, for each one, the detected
-     * language as well as a score indicating the model's confidence that the
-     * inferred language is correct.  Scores close to 1 indicate high certainty in
-     * the result.  120 languages are supported.
-     * @param documents - A collection of input strings to analyze.
-     * @param countryHint - Indicates the country of origin for all of
-     *   the input strings to assist the text analytics model in predicting
-     *   the language they are written in.  If unspecified, this value will be
-     *   set to the default country hint in `TextAnalyticsClientOptions`.
-     *   If set to an empty string, or the string "none", the service will apply a
-     *   model where the country is explicitly unset.
-     *   The same country hint is applied to all strings in the input collection.
-     * @param options - Optional parameters for the operation.
+     * Creates a poller from the serialized state of another poller. This can be
+     * useful when you want to create pollers on a different host or a poller
+     * needs to be constructed after the original one is not in scope.
+     *
+     * @param serializedState - the serialized state of another poller. It is the
+     *                          result of `poller.toString()`
+     * @param options - optional settings for the operation
+     *
+     * # Example
+     *
+     * `client.beginAnalyzeBatch` returns a promise that will resolve to a poller.
+     * The state of the poller can be serialized and used to create another as follows:
+     *
+     * ```js
+     * const serializedState = poller.toString();
+     * const rehydratedPoller = await client.createAnalyzeBatchPoller(serializedState);
+     * const actionResults = await rehydratedPoller.pollUntilDone();
+     * ```
      */
-    detectLanguage(documents: string[], countryHint?: string, options?: DetectLanguageOptions): Promise<DetectLanguageResultArray>;
-    /**
-     * Runs a predictive model to determine the language that the passed-in
-     * input document are written in, and returns, for each one, the detected
-     * language as well as a score indicating the model's confidence that the
-     * inferred language is correct.  Scores close to 1 indicate high certainty in
-     * the result.  120 languages are supported.
-     * @param documents - A collection of input documents to analyze.
-     * @param options - Optional parameters for the operation.
-     */
-    detectLanguage(documents: DetectLanguageInput[], options?: DetectLanguageOptions): Promise<DetectLanguageResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of named entities
-     * in the passed-in input strings, and categorize those entities into types
-     * such as person, location, or organization.  For more information on
-     * available categories, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/named-entity-types}.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input strings to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Optional parameters for the operation.
-     */
-    recognizeEntities(documents: string[], language?: string, options?: RecognizeCategorizedEntitiesOptions): Promise<RecognizeCategorizedEntitiesResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of named entities
-     * in the passed-in input documents, and categorize those entities into types
-     * such as person, location, or organization.  For more information on
-     * available categories, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/named-entity-types}.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input documents to analyze.
-     * @param options - Optional parameters for the operation.
-     */
-    recognizeEntities(documents: TextDocumentInput[], options?: RecognizeCategorizedEntitiesOptions): Promise<RecognizeCategorizedEntitiesResultArray>;
-    /**
-     * Runs a predictive model to identify the positive, negative, neutral, or mixed
-     * sentiment contained in the input strings, as well as scores indicating
-     * the model's confidence in each of the predicted sentiments. Optionally it
-     * can also identify targets in the text and assessments about it through
-     * opinion mining. For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input strings to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the lanuage is explicitly set to "None".
-     * @param options - Optional parameters that includes enabling opinion mining.
-     */
-    analyzeSentiment(documents: string[], language?: string, options?: AnalyzeSentimentOptions): Promise<AnalyzeSentimentResultArray>;
-    /**
-     * Runs a predictive model to identify the positive, negative or neutral, or mixed
-     * sentiment contained in the input documents, as well as scores indicating
-     * the model's confidence in each of the predicted sentiments.Optionally it
-     * can also identify targets in the text and assessments about it through
-     * opinion mining. For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input documents to analyze.
-     * @param options - Optional parameters that includes enabling opinion mining.
-     */
-    analyzeSentiment(documents: TextDocumentInput[], options?: AnalyzeSentimentOptions): Promise<AnalyzeSentimentResultArray>;
-    /**
-     * Runs a model to identify a collection of significant phrases
-     * found in the passed-in input strings.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input strings to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Options for the operation.
-     */
-    extractKeyPhrases(documents: string[], language?: string, options?: ExtractKeyPhrasesOptions): Promise<ExtractKeyPhrasesResultArray>;
-    /**
-     * Runs a model to identify a collection of significant phrases
-     * found in the passed-in input documents.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input documents to analyze.
-     * @param options - Options for the operation.
-     */
-    extractKeyPhrases(documents: TextDocumentInput[], options?: ExtractKeyPhrasesOptions): Promise<ExtractKeyPhrasesResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of entities containing
-     * personally identifiable information found in the passed-in input strings,
-     * and categorize those entities into types such as US social security
-     * number, drivers license number, or credit card number.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/language-support}.
-     * @param inputs - The input strings to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Options for the operation.
-     */
-    recognizePiiEntities(inputs: string[], language?: string, options?: RecognizePiiEntitiesOptions): Promise<RecognizePiiEntitiesResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of entities containing
-     * personally identifiable information found in the passed-in input documents,
-     * and categorize those entities into types such as US social security
-     * number, drivers license number, or credit card number.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/language-support}.
-     * @param inputs - The input documents to analyze.
-     * @param options - Optional parameters for the operation.
-     */
-    recognizePiiEntities(inputs: TextDocumentInput[], options?: RecognizePiiEntitiesOptions): Promise<RecognizePiiEntitiesResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of entities
-     * found in the passed-in input strings, and include information linking the
-     * entities to their corresponding entries in a well-known knowledge base.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input strings to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Options for the operation.
-     */
-    recognizeLinkedEntities(documents: string[], language?: string, options?: RecognizeLinkedEntitiesOptions): Promise<RecognizeLinkedEntitiesResultArray>;
-    /**
-     * Runs a predictive model to identify a collection of entities
-     * found in the passed-in input documents, and include information linking the
-     * entities to their corresponding entries in a well-known knowledge base.
-     * For a list of languages supported by this operation, @see
-     * {@link https://docs.microsoft.com/azure/cognitive-services/text-analytics/language-support}.
-     * @param documents - The input documents to analyze.
-     * @param options - Options for the operation.
-     */
-    recognizeLinkedEntities(documents: TextDocumentInput[], options?: RecognizeLinkedEntitiesOptions): Promise<RecognizeLinkedEntitiesResultArray>;
-    /**
-     * Start a healthcare analysis operation to recognize healthcare related entities (drugs, conditions,
-     * symptoms, etc) and their relations.
-     * @param documents - Collection of documents to analyze.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Options for the operation.
-     */
-    beginAnalyzeHealthcareEntities(documents: string[], language?: string, options?: BeginAnalyzeHealthcareEntitiesOptions): Promise<AnalyzeHealthcareEntitiesPollerLike>;
-    /**
-     * Start a healthcare analysis operation to recognize healthcare related entities (drugs, conditions,
-     * symptoms, etc) and their relations.
-     * @param documents - Collection of documents to analyze.
-     * @param options - Options for the operation.
-     */
-    beginAnalyzeHealthcareEntities(documents: TextDocumentInput[], options?: BeginAnalyzeHealthcareEntitiesOptions): Promise<AnalyzeHealthcareEntitiesPollerLike>;
-    /**
-     * Submit a collection of text documents for analysis. Specify one or more unique actions to be executed.
-     * @param documents - Collection of documents to analyze
-     * @param actions - TextAnalyticsActions to execute.
-     * @param language - The language that all the input strings are
-          written in. If unspecified, this value will be set to the default
-          language in `TextAnalyticsClientOptions`.
-          If set to an empty string, the service will apply a model
-          where the language is explicitly set to "None".
-     * @param options - Options for the operation.
-     */
-    beginAnalyzeActions(documents: string[], actions: TextAnalyticsActions, language?: string, options?: BeginAnalyzeActionsOptions): Promise<AnalyzeActionsPollerLike>;
-    /**
-     * Submit a collection of text documents for analysis. Specify one or more unique actions to be executed.
-     * @param documents - Collection of documents to analyze
-     * @param actions - TextAnalyticsActions to execute.
-     * @param options - Options for the operation.
-     */
-    beginAnalyzeActions(documents: TextDocumentInput[], actions: TextAnalyticsActions, options?: BeginAnalyzeActionsOptions): Promise<AnalyzeActionsPollerLike>;
-}
-
-/**
- * Client options used to configure TextAnalytics API requests.
- */
-export declare interface TextAnalyticsClientOptions extends CommonClientOptions {
+    restoreAnalyzeBatchPoller(serializedState: string, options?: RestoreAnalyzeBatchPollerOptions): Promise<AnalyzeBatchPoller>;
+}
+
+/**
+ * Configuration options for {@link TextAnalysisClient}.
+ */
+export declare interface TextAnalysisClientOptions extends CommonClientOptions {
     /**
      * The default country hint to use. Defaults to "us".
      */
@@ -1838,16 +2147,20 @@ export declare interface TextAnalyticsClientOptions extends CommonClientOptions
      * The default language to use. Defaults to "en".
      */
     defaultLanguage?: string;
+    /**
+     * The version of the Cognitive Language Service API to use.
+     */
+    apiVersion?: string;
 }
 
 /**
- * Type describing an error from the Text Analytics service.
+ * Type describing an API error.
  */
-export declare interface TextAnalyticsError {
+export declare interface TextAnalysisError {
     /**
-     * A code describing the kind of error produced
+     * A code describing the kind of error produced. See {@link KnownTextAnalysisErrorCode}.
      */
-    readonly code: ErrorCode;
+    readonly code: string;
     /**
      * A message from the service explaining the error
      */
@@ -1859,10 +2172,9 @@ export declare interface TextAnalyticsError {
 }
 
 /**
- * Base type for error results of text analytics operations corresponding to a
- * single document.
+ * Base type for error results of an action corresponding to a single document.
  */
-export declare interface TextAnalyticsErrorResult {
+export declare interface TextAnalysisErrorResult {
     /**
      * Unique, non-empty document identifier.
      */
@@ -1870,50 +2182,35 @@ export declare interface TextAnalyticsErrorResult {
     /**
      * The Error for this document result.
      */
-    readonly error: TextAnalyticsError;
+    readonly error: TextAnalysisError;
 }
 
 /**
- * Options common to all text analytics operations.
+ * Options common to all operations.
  */
-export declare interface TextAnalyticsOperationOptions extends OperationOptions {
-    /**
-     * This value indicates which model will be used for scoring. If a model-version is
-     * not specified, the API should default to the latest, non-preview version.
-     * For supported model versions, see operation-specific documentation, for example:
-     * https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-how-to-sentiment-analysis#model-versioning
-     */
-    modelVersion?: string;
+export declare interface TextAnalysisOperationOptions extends OperationOptions {
     /**
      * If set to true, response will contain input and document level statistics.
      */
     includeStatistics?: boolean;
     /**
-     * If set to true (the default for `beginAnalyzeHealthcareEntities` and `recognizePiiEntities`),
-     * you opt-out of having your text input logged for troubleshooting. By default, Text Analytics
-     * logs your input text for 48 hours, solely to allow for troubleshooting issues. Setting this
-     * parameter to true, disables input logging and may limit our ability to remediate issues that
-     * occur.
+     * The version of the Cognitive Language Service API to use.
      */
-    disableServiceLogs?: boolean;
+    apiVersion?: string;
 }
 
-/** Defines values for State. */
-export declare type TextAnalyticsOperationStatus = "notStarted" | "running" | "succeeded" | "failed" | "rejected" | "cancelled" | "cancelling";
-
 /**
- * Base type for results of text analytics operations corresponding to a single
- * input document.
+ * Base type for results of an action corresponding to a single input document.
  */
-export declare interface TextAnalyticsSuccessResult {
+export declare interface TextAnalysisSuccessResult {
     /**
      * Unique, non-empty document identifier.
      */
     readonly id: string;
     /**
-     * Statistics about the input document and how it was processed
-     * by the service. This property will have a value when includeStatistics is set to true
-     * in the client call.
+     * Statistics about the input document and how it was processed by the service.
+     * This property will have a value when includeStatistics is set to true in
+     * the client call.
      */
     readonly statistics?: TextDocumentStatistics;
     /**
@@ -1921,21 +2218,13 @@ export declare interface TextAnalyticsSuccessResult {
      *
      * If no warnings were returned, this array will be empty.
      */
-    readonly warnings: TextAnalyticsWarning[];
+    readonly warnings: DocumentWarning[];
     /**
-     * Discriminant to determine if that this is an error result.
+     * Discriminant to determine if this is an error result.
      */
     readonly error?: undefined;
 }
 
-/** Represents a warning encountered while processing a document. */
-export declare interface TextAnalyticsWarning {
-    /** Error code. */
-    code: WarningCode;
-    /** Warning message. */
-    message: string;
-}
-
 /** if includeStatistics=true was specified in the request this field will contain information about the request payload. */
 export declare interface TextDocumentBatchStatistics {
     /** Number of documents submitted in the request. */
@@ -1948,7 +2237,7 @@ export declare interface TextDocumentBatchStatistics {
     transactionCount: number;
 }
 
-/** An object representing an individual text document to be analyzed by the Text Analytics service. The document contains a unique document ID, the full text of the document, and the language of the document's text. */
+/** An object representing an individual text document to be analyzed by the Language service. The document contains a unique document ID, the full text of the document, and the language of the document's text. */
 export declare interface TextDocumentInput {
     /** A unique, non-empty document identifier. */
     id: string;
@@ -1966,8 +2255,8 @@ export declare interface TextDocumentStatistics {
     transactionCount: number;
 }
 
-/** Defines values for TokenSentimentValue. */
-export declare type TokenSentimentValue = "positive" | "mixed" | "negative";
+/** Defines values for TokenSentimentLabel. */
+export declare type TokenSentimentLabel = "positive" | "mixed" | "negative";
 
 /**
  * Defines values for WarningCode. \