@azure/search-documents 12.0.0-beta.4 → 12.1.0-beta.1

package/types/search-documents.d.ts

@@ -5,6 +5,7 @@ import { ExtendedCommonClientOptions } from '@azure/core-http-compat';
 import { KeyCredential } from '@azure/core-auth';
 import { OperationOptions } from '@azure/core-client';
 import { PagedAsyncIterableIterator } from '@azure/core-paging';
+import { Pipeline } from '@azure/core-rest-pipeline';
 import { RestError } from '@azure/core-rest-pipeline';
 import { TokenCredential } from '@azure/core-auth';
 
@@ -50,31 +51,32 @@ export declare interface AnalyzeRequest {
     /**
      * The name of the analyzer to use to break the given text. If this parameter is not specified,
      * you must specify a tokenizer instead. The tokenizer and analyzer parameters are mutually
-     * exclusive. KnownAnalyzerNames is an enum containing known values.
+     * exclusive. {@link KnownAnalyzerNames} is an enum containing built-in analyzer names.
      * NOTE: Either analyzerName or tokenizerName is required in an AnalyzeRequest.
      */
-    analyzerName?: string;
+    analyzerName?: LexicalAnalyzerName;
     /**
      * The name of the tokenizer to use to break the given text. If this parameter is not specified,
      * you must specify an analyzer instead. The tokenizer and analyzer parameters are mutually
-     * exclusive. KnownTokenizerNames is an enum containing known values.
+     * exclusive. {@link KnownTokenizerNames} is an enum containing built-in tokenizer names.
      * NOTE: Either analyzerName or tokenizerName is required in an AnalyzeRequest.
      */
-    tokenizerName?: string;
+    tokenizerName?: LexicalTokenizerName;
     /**
-     * The name of the normalizer to use to normalize the given text.
+     * The name of the normalizer to use to normalize the given text. {@link KnownNormalizerNames} is
+     * an enum containing built-in analyzer names.
      */
     normalizerName?: LexicalNormalizerName;
     /**
      * An optional list of token filters to use when breaking the given text. This parameter can only
      * be set when using the tokenizer parameter.
      */
-    tokenFilters?: string[];
+    tokenFilters?: TokenFilterName[];
     /**
      * An optional list of character filters to use when breaking the given text. This parameter can
      * only be set when using the tokenizer parameter.
      */
-    charFilters?: string[];
+    charFilters?: CharFilterName[];
 }
 
 /** The result of testing an analyzer on text. */
@@ -88,76 +90,13 @@ export declare interface AnalyzeResult {
  */
 export declare type AnalyzeTextOptions = OperationOptions & AnalyzeRequest;
 
-/** An answer is a text passage extracted from the contents of the most relevant documents that matched the query. Answers are extracted from the top search results. Answer candidates are scored and the top answers are selected. */
-export declare interface AnswerResult {
-    /** Describes unknown properties. The value of an unknown property can be of "any" type. */
-    [property: string]: any;
-    /**
-     * The score value represents how relevant the answer is to the query relative to other answers returned for the query.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly score: number;
-    /**
-     * The key of the document the answer was extracted from.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly key: string;
-    /**
-     * The text passage extracted from the document contents as the answer.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly text: string;
-    /**
-     * Same text passage as in the Text property with highlighted text phrases most relevant to the query.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly highlights?: string;
-}
-
-/**
- * This parameter is only valid if the query type is 'semantic'. If set, the query returns answers
- * extracted from key passages in the highest ranked documents. The number of answers returned can
- * be configured by appending the pipe character '|' followed by the 'count-\<number of answers\>' option
- * after the answers parameter value, such as 'extractive|count-3'. Default count is 1. The
- * confidence threshold can be configured by appending the pipe character '|' followed by the
- * 'threshold-\<confidence threshold\>' option after the answers parameter value, such as
- * 'extractive|threshold-0.9'. Default threshold is 0.7.
- */
-export declare type Answers = string;
-
-/**
- * A value that specifies whether answers should be returned as part of the search response.
- * This parameter is only valid if the query type is 'semantic'. If set to `extractive`, the query
- * returns answers extracted from key passages in the highest ranked documents.
- */
-export declare type AnswersOptions = {
-    /**
-     * Extracts answer candidates from the contents of the documents returned in response to a
-     * query expressed as a question in natural language.
-     */
-    answers: "extractive";
-    /**
-     * The number of answers returned. Default count is 1
-     */
-    count?: number;
-    /**
-     * The confidence threshold. Default threshold is 0.7
-     */
-    threshold?: number;
-} | {
-    /**
-     * Do not return answers for the query.
-     */
-    answers: "none";
-};
-
 /** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. This token filter is implemented using Apache Lucene. */
-export declare type AsciiFoldingTokenFilter = BaseTokenFilter & {
+export declare interface AsciiFoldingTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.AsciiFoldingTokenFilter";
     /** A value indicating whether the original token will be kept. Default is false. */
     preserveOriginal?: boolean;
-};
+}
 
 /** The result of Autocomplete requests. */
 export declare interface AutocompleteItem {
@@ -258,7 +197,7 @@ export declare interface AzureActiveDirectoryApplicationCredentials {
 export { AzureKeyCredential }
 
 /** The AML skill allows you to extend AI enrichment with a custom Azure Machine Learning (AML) model. Once an AML model is trained and deployed, an AML skill integrates it into AI enrichment. */
-export declare type AzureMachineLearningSkill = BaseSearchIndexerSkill & {
+export declare interface AzureMachineLearningSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Custom.AmlSkill";
     /** (Required for no authentication or key authentication) The scoring URI of the AML service to which the JSON payload will be sent. Only the https URI scheme is allowed. */
@@ -273,7 +212,7 @@ export declare type AzureMachineLearningSkill = BaseSearchIndexerSkill & {
     region?: string;
     /** (Optional) When specified, indicates the number of calls the indexer will make in parallel to the endpoint you have provided. You can decrease this value if your endpoint is failing under too high of a request load, or raise it if your endpoint is able to accept more requests and you would like an increase in the performance of the indexer. If not set, a default value of 5 is used. The degreeOfParallelism can be set to a maximum of 10 and a minimum of 1. */
     degreeOfParallelism?: number;
-};
+}
 
 /** Allows you to generate a vector embedding for a given text input using the Azure Open AI service. */
 export declare interface AzureOpenAIEmbeddingSkill extends BaseSearchIndexerSkill {
@@ -317,11 +256,11 @@ export declare interface BaseCharFilter {
     name: string;
 }
 
-/** Base type for describing any cognitive service resource attached to a skillset. */
+/** Base type for describing any Azure AI service resource attached to a skillset. */
 export declare interface BaseCognitiveServicesAccount {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.DefaultCognitiveServices" | "#Microsoft.Azure.Search.CognitiveServicesByKey";
-    /** Description of the cognitive service resource attached to a skillset. */
+    /** Description of the Azure AI service resource attached to a skillset. */
     description?: string;
 }
 
@@ -395,6 +334,129 @@ export declare interface BaseSearchIndexerSkill {
     outputs: OutputFieldMappingEntry[];
 }
 
+/**
+ * Parameters for filtering, sorting, faceting, paging, and other search query behaviors.
+ */
+export declare interface BaseSearchRequestOptions<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> {
+    /**
+     * A value that specifies whether to fetch the total count of results. Default is false. Setting
+     * this value to true may have a performance impact. Note that the count returned is an
+     * approximation.
+     */
+    includeTotalCount?: boolean;
+    /**
+     * The list of facet expressions to apply to the search query. Each facet expression contains a
+     * field name, optionally followed by a comma-separated list of name:value pairs.
+     */
+    facets?: string[];
+    /**
+     * The OData $filter expression to apply to the search query.
+     */
+    filter?: string;
+    /**
+     * The comma-separated list of field names to use for hit highlights. Only searchable fields can
+     * be used for hit highlighting.
+     */
+    highlightFields?: string;
+    /**
+     * A string tag that is appended to hit highlights. Must be set with highlightPreTag. Default is
+     * &lt;/em&gt;.
+     */
+    highlightPostTag?: string;
+    /**
+     * A string tag that is prepended to hit highlights. Must be set with highlightPostTag. Default
+     * is &lt;em&gt;.
+     */
+    highlightPreTag?: string;
+    /**
+     * A number between 0 and 100 indicating the percentage of the index that must be covered by a
+     * search query in order for the query to be reported as a success. This parameter can be useful
+     * for ensuring search availability even for services with only one replica. The default is 100.
+     */
+    minimumCoverage?: number;
+    /**
+     * The list of OData $orderby expressions by which to sort the results. Each
+     * expression can be either a field name or a call to either the geo.distance() or the
+     * search.score() functions. Each expression can be followed by asc to indicate ascending, or
+     * desc to indicate descending. The default is ascending order. Ties will be broken by the match
+     * scores of documents. If no $orderby is specified, the default sort order is descending by
+     * document match score. There can be at most 32 $orderby clauses.
+     */
+    orderBy?: string[];
+    /**
+     * A value that specifies the syntax of the search query. The default is 'simple'. Use 'full' if
+     * your query uses the Lucene query syntax. Possible values include: 'simple', 'full', 'semantic'
+     */
+    queryType?: QueryType;
+    /**
+     * The list of parameter values to be used in scoring functions (for example,
+     * referencePointParameter) using the format name-values. For example, if the scoring profile
+     * defines a function with a parameter called 'mylocation' the parameter string would be
+     * "mylocation--122.2,44.8" (without the quotes).
+     */
+    scoringParameters?: string[];
+    /**
+     * The name of a scoring profile to evaluate match scores for matching documents in order to sort
+     * the results.
+     */
+    scoringProfile?: string;
+    /**
+     * The comma-separated list of field names to which to scope the full-text search. When using
+     * fielded search (fieldName:searchExpression) in a full Lucene query, the field names of each
+     * fielded search expression take precedence over any field names listed in this parameter.
+     */
+    searchFields?: SearchFieldArray<TModel>;
+    /**
+     * The language of the query.
+     */
+    queryLanguage?: QueryLanguage;
+    /**
+     * Improve search recall by spell-correcting individual search query terms.
+     */
+    speller?: Speller;
+    /**
+     * A value that specifies whether any or all of the search terms must be matched in order to
+     * count the document as a match. Possible values include: 'any', 'all'
+     */
+    searchMode?: SearchMode;
+    /**
+     * A value that specifies whether we want to calculate scoring statistics (such as document
+     * frequency) globally for more consistent scoring, or locally, for lower latency. Possible
+     * values include: 'Local', 'Global'
+     */
+    scoringStatistics?: ScoringStatistics;
+    /**
+     * A value to be used to create a sticky session, which can help to get more consistent results.
+     * As long as the same sessionId is used, a best-effort attempt will be made to target the same
+     * replica set. Be wary that reusing the same sessionID values repeatedly can interfere with the
+     * load balancing of the requests across replicas and adversely affect the performance of the
+     * search service. The value used as sessionId cannot start with a '_' character.
+     */
+    sessionId?: string;
+    /**
+     * The list of fields to retrieve. If unspecified, all fields marked as
+     * retrievable in the schema are included.
+     */
+    select?: SelectArray<TFields>;
+    /**
+     * The number of search results to skip. This value cannot be greater than 100,000. If you need
+     * to scan documents in sequence, but cannot use skip due to this limitation, consider using
+     * orderby on a totally-ordered key and filter with a range query instead.
+     */
+    skip?: number;
+    /**
+     * The number of search results to retrieve. This can be used in conjunction with $skip to
+     * implement client-side paging of search results. If results are truncated due to server-side
+     * paging, the response will include a continuation token that can be used to issue another
+     * Search request for the next page of results.
+     */
+    top?: number;
+    /**
+     * Defines options for vector search queries
+     */
+    vectorSearchOptions?: VectorSearchOptions<TModel>;
+}
+
 /** Base type for token filters. */
 export declare interface BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
@@ -411,8 +473,19 @@ export declare interface BaseVectorQuery<TModel extends object> {
     kNearestNeighborsCount?: number;
     /** Vector Fields of type Collection(Edm.Single) to be included in the vector searched. */
     fields?: SearchFieldArray<TModel>;
-    /** When true, triggers an exhaustive k-nearest neighbor search across all vectors within the vector index. Useful for scenarios where exact matches are critical, such as determining ground truth values. */
+    /**
+     * When true, triggers an exhaustive k-nearest neighbor search across all vectors within the
+     * vector index. Useful for scenarios where exact matches are critical, such as determining ground
+     * truth values.
+     */
     exhaustive?: boolean;
+    /**
+     * Oversampling factor. Minimum value is 1. It overrides the 'defaultOversampling' parameter
+     * configured in the index definition. It can be set only when 'rerankWithOriginalVectors' is
+     * true. This parameter is only permitted when a compression method is used on the underlying
+     * vector field.
+     */
+    oversampling?: number;
 }
 
 /** Contains configuration options specific to the algorithm used during indexing and/or querying. */
@@ -423,6 +496,18 @@ export declare interface BaseVectorSearchAlgorithmConfiguration {
     name: string;
 }
 
+/** Contains configuration options specific to the compression method used during indexing or querying. */
+export declare interface BaseVectorSearchCompressionConfiguration {
+    /** Polymorphic discriminator, which specifies the different types this object can be */
+    kind: "scalarQuantization";
+    /** The name to associate with this particular configuration. */
+    name: string;
+    /** If set to true, once the ordered set of results calculated using compressed vectors are obtained, they will be reranked again by recalculating the full-precision similarity scores. This will improve recall at the expense of latency. */
+    rerankWithOriginalVectors?: boolean;
+    /** Default oversampling factor. Oversampling will internally request more documents (specified by this multiplier) in the initial search. This increases the set of results that will be reranked using recomputed similarity scores from full-precision vectors. Minimum value is 1, meaning no oversampling (1x). This parameter can only be set when rerankWithOriginalVectors is true. Higher values improve recall at the expense of latency. */
+    defaultOversampling?: number;
+}
+
 /** Contains specific details for a vectorization method to be used during query time. */
 export declare interface BaseVectorSearchVectorizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
@@ -431,88 +516,24 @@ export declare interface BaseVectorSearchVectorizer {
     name: string;
 }
 
-/**
- * Defines values for BlobIndexerDataToExtract. \
- * {@link KnownBlobIndexerDataToExtract} can be used interchangeably with BlobIndexerDataToExtract,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **storageMetadata**: Indexes just the standard blob properties and user-specified metadata. \
- * **allMetadata**: Extracts metadata provided by the Azure blob storage subsystem and the content-type specific metadata (for example, metadata unique to just .png files are indexed). \
- * **contentAndMetadata**: Extracts all metadata and textual content from each blob.
- */
-export declare type BlobIndexerDataToExtract = string;
+export declare type BlobIndexerDataToExtract = "storageMetadata" | "allMetadata" | "contentAndMetadata";
 
-/**
- * Defines values for BlobIndexerImageAction. \
- * {@link KnownBlobIndexerImageAction} can be used interchangeably with BlobIndexerImageAction,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: Ignores embedded images or image files in the data set.  This is the default. \
- * **generateNormalizedImages**: Extracts text from images (for example, the word "STOP" from a traffic stop sign), and embeds it into the content field.  This action requires that "dataToExtract" is set to "contentAndMetadata".  A normalized image refers to additional processing resulting in uniform image output, sized and rotated to promote consistent rendering when you include images in visual search results. This information is generated for each image when you use this option. \
- * **generateNormalizedImagePerPage**: Extracts text from images (for example, the word "STOP" from a traffic stop sign), and embeds it into the content field, but treats PDF files differently in that each page will be rendered as an image and normalized accordingly, instead of extracting embedded images.  Non-PDF file types will be treated the same as if "generateNormalizedImages" was set.
- */
-export declare type BlobIndexerImageAction = string;
+export declare type BlobIndexerImageAction = "none" | "generateNormalizedImages" | "generateNormalizedImagePerPage";
 
-/**
- * Defines values for BlobIndexerParsingMode. \
- * {@link KnownBlobIndexerParsingMode} can be used interchangeably with BlobIndexerParsingMode,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **default**: Set to default for normal file processing. \
- * **text**: Set to text to improve indexing performance on plain text files in blob storage. \
- * **delimitedText**: Set to delimitedText when blobs are plain CSV files. \
- * **json**: Set to json to extract structured content from JSON files. \
- * **jsonArray**: Set to jsonArray to extract individual elements of a JSON array as separate documents in Azure Cognitive Search. \
- * **jsonLines**: Set to jsonLines to extract individual JSON entities, separated by a new line, as separate documents in Azure Cognitive Search.
- */
-export declare type BlobIndexerParsingMode = string;
+export declare type BlobIndexerParsingMode = "default" | "text" | "delimitedText" | "json" | "jsonArray" | "jsonLines";
 
-/**
- * Defines values for BlobIndexerPDFTextRotationAlgorithm. \
- * {@link KnownBlobIndexerPDFTextRotationAlgorithm} can be used interchangeably with BlobIndexerPDFTextRotationAlgorithm,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: Leverages normal text extraction.  This is the default. \
- * **detectAngles**: May produce better and more readable text extraction from PDF files that have rotated text within them.  Note that there may be a small performance speed impact when this parameter is used.  This parameter only applies to PDF files, and only to PDFs with embedded text.  If the rotated text appears within an embedded image in the PDF, this parameter does not apply.
- */
-export declare type BlobIndexerPDFTextRotationAlgorithm = string;
+export declare type BlobIndexerPDFTextRotationAlgorithm = "none" | "detectAngles";
 
 /** Ranking function based on the Okapi BM25 similarity algorithm. BM25 is a TF-IDF-like algorithm that includes length normalization (controlled by the 'b' parameter) as well as term frequency saturation (controlled by the 'k1' parameter). */
-export declare type BM25Similarity = Similarity & {
+export declare interface BM25Similarity extends Similarity {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.BM25Similarity";
     /** This property controls the scaling function between the term frequency of each matching terms and the final relevance score of a document-query pair. By default, a value of 1.2 is used. A value of 0.0 means the score does not scale with an increase in term frequency. */
     k1?: number;
     /** This property controls how the length of a document affects the relevance score. By default, a value of 0.75 is used. A value of 0.0 means no length normalization is applied, while a value of 1.0 means the score is fully normalized by the length of the document. */
     b?: number;
-};
-
-/** Captions are the most representative passages from the document relatively to the search query. They are often used as document summary. Captions are only returned for queries of type 'semantic'.. */
-export declare interface CaptionResult {
-    /** Describes unknown properties. The value of an unknown property can be of "any" type. */
-    [property: string]: any;
-    /**
-     * A representative text passage extracted from the document most relevant to the search query.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly text?: string;
-    /**
-     * Same text passage as in the Text property with highlighted phrases most relevant to the query.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly highlights?: string;
 }
 
-/**
- * Defines values for Captions. \
- * {@link KnownCaptions} can be used interchangeably with Captions,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: Do not return captions for the query. \
- * **extractive**: Extracts captions from the matching documents that contain passages relevant to the search query.
- */
-export declare type Captions = string;
-
 /**
  * Contains the possible cases for CharFilter.
  */
@@ -528,47 +549,47 @@ export declare type CharFilter = MappingCharFilter | PatternReplaceCharFilter;
 export declare type CharFilterName = string;
 
 /** Forms bigrams of CJK terms that are generated from the standard tokenizer. This token filter is implemented using Apache Lucene. */
-export declare type CjkBigramTokenFilter = BaseTokenFilter & {
+export declare interface CjkBigramTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.CjkBigramTokenFilter";
     /** The scripts to ignore. */
     ignoreScripts?: CjkBigramTokenFilterScripts[];
     /** A value indicating whether to output both unigrams and bigrams (if true), or just bigrams (if false). Default is false. */
     outputUnigrams?: boolean;
-};
+}
 
 /** Defines values for CjkBigramTokenFilterScripts. */
 export declare type CjkBigramTokenFilterScripts = "han" | "hiragana" | "katakana" | "hangul";
 
 /** Legacy similarity algorithm which uses the Lucene TFIDFSimilarity implementation of TF-IDF. This variation of TF-IDF introduces static document length normalization as well as coordinating factors that penalize documents that only partially match the searched queries. */
-export declare type ClassicSimilarity = Similarity & {
+export declare interface ClassicSimilarity extends Similarity {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.ClassicSimilarity";
-};
+}
 
 /** Grammar-based tokenizer that is suitable for processing most European-language documents. This tokenizer is implemented using Apache Lucene. */
-export declare type ClassicTokenizer = BaseLexicalTokenizer & {
+export declare interface ClassicTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.ClassicTokenizer";
     /** The maximum token length. Default is 255. Tokens longer than the maximum length are split. The maximum token length that can be used is 300 characters. */
     maxTokenLength?: number;
-};
+}
 
 /**
  * Contains the possible cases for CognitiveServicesAccount.
  */
 export declare type CognitiveServicesAccount = DefaultCognitiveServicesAccount | CognitiveServicesAccountKey;
 
-/** A cognitive service resource provisioned with a key that is attached to a skillset. */
-export declare type CognitiveServicesAccountKey = BaseCognitiveServicesAccount & {
+/** The multi-region account key of an Azure AI service resource that's attached to a skillset. */
+export declare interface CognitiveServicesAccountKey extends BaseCognitiveServicesAccount {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.CognitiveServicesByKey";
-    /** The key used to provision the cognitive service resource attached to a skillset. */
+    /** The key used to provision the Azure AI service resource attached to a skillset. */
     key: string;
-};
+}
 
 /** Construct bigrams for frequently occurring terms while indexing. Single terms are still indexed too, with bigrams overlaid. This token filter is implemented using Apache Lucene. */
-export declare type CommonGramTokenFilter = BaseTokenFilter & {
+export declare interface CommonGramTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.CommonGramTokenFilter";
     /** The set of common words. */
@@ -577,7 +598,7 @@ export declare type CommonGramTokenFilter = BaseTokenFilter & {
     ignoreCase?: boolean;
     /** A value that indicates whether the token filter is in query mode. When in query mode, the token filter generates bigrams and then removes common words and single terms followed by a common word. Default is false. */
     useQueryMode?: boolean;
-};
+}
 
 /**
  * Defines values for ComplexDataType.
@@ -608,10 +629,10 @@ export declare interface ComplexField {
 }
 
 /** A skill that enables scenarios that require a Boolean operation to determine the data to assign to an output. */
-export declare type ConditionalSkill = BaseSearchIndexerSkill & {
+export declare interface ConditionalSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Util.ConditionalSkill";
-};
+}
 
 /** Defines options to control Cross-Origin Resource Sharing (CORS) for an index. */
 export declare interface CorsOptions {
@@ -766,21 +787,21 @@ export declare interface CustomAnalyzer {
     name: string;
     /**
      * The name of the tokenizer to use to divide continuous text into a sequence of tokens, such as
-     * breaking a sentence into words. KnownTokenizerNames is an enum containing known values.
+     * breaking a sentence into words. {@link KnownTokenizerNames} is an enum containing built-in tokenizer names.
      */
-    tokenizerName: string;
+    tokenizerName: LexicalTokenizerName;
     /**
      * A list of token filters used to filter out or modify the tokens generated by a tokenizer. For
      * example, you can specify a lowercase filter that converts all characters to lowercase. The
      * filters are run in the order in which they are listed.
      */
-    tokenFilters?: string[];
+    tokenFilters?: TokenFilterName[];
     /**
      * A list of character filters used to prepare input text before it is processed by the
      * tokenizer. For instance, they can replace certain characters or symbols. The filters are run
      * in the order in which they are listed.
      */
-    charFilters?: string[];
+    charFilters?: CharFilterName[];
 }
 
 /** An object that contains information about the matches that were found, and related metadata. */
@@ -824,7 +845,7 @@ export declare interface CustomEntityAlias {
 }
 
 /** A skill looks for text from a custom, user-defined list of words and phrases. */
-export declare type CustomEntityLookupSkill = BaseSearchIndexerSkill & {
+export declare interface CustomEntityLookupSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.CustomEntityLookupSkill";
     /** A value indicating which language code to use. Default is en. */
@@ -839,34 +860,19 @@ export declare type CustomEntityLookupSkill = BaseSearchIndexerSkill & {
     globalDefaultAccentSensitive?: boolean;
     /** A global flag for FuzzyEditDistance. If FuzzyEditDistance is not set in CustomEntity, this value will be the default value. */
     globalDefaultFuzzyEditDistance?: number;
-};
+}
 
-/**
- * Defines values for CustomEntityLookupSkillLanguage. \
- * {@link KnownCustomEntityLookupSkillLanguage} can be used interchangeably with CustomEntityLookupSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **da**: Danish \
- * **de**: German \
- * **en**: English \
- * **es**: Spanish \
- * **fi**: Finnish \
- * **fr**: French \
- * **it**: Italian \
- * **ko**: Korean \
- * **pt**: Portuguese
- */
-export declare type CustomEntityLookupSkillLanguage = string;
+export declare type CustomEntityLookupSkillLanguage = "da" | "de" | "en" | "es" | "fi" | "fr" | "it" | "ko" | "pt";
 
 /** Allows you to configure normalization for filterable, sortable, and facetable fields, which by default operate with strict matching. This is a user-defined configuration consisting of at least one or more filters, which modify the token that is stored. */
-export declare type CustomNormalizer = BaseLexicalNormalizer & {
+export declare interface CustomNormalizer extends BaseLexicalNormalizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.CustomNormalizer";
     /** A list of token filters used to filter out or modify the input token. For example, you can specify a lowercase filter that converts all characters to lowercase. The filters are run in the order in which they are listed. */
     tokenFilters?: TokenFilterName[];
     /** A list of character filters used to prepare input text before it is processed. For instance, they can replace certain characters or symbols. The filters are run in the order in which they are listed. */
     charFilters?: CharFilterName[];
-};
+}
 
 /** Contains the parameters specific to generating vector embeddings via a custom endpoint. */
 export declare type CustomVectorizer = BaseVectorSearchVectorizer & {
@@ -917,11 +923,11 @@ export declare const DEFAULT_FLUSH_WINDOW: number;
  */
 export declare const DEFAULT_RETRY_COUNT: number;
 
-/** An empty object that represents the default cognitive service resource for a skillset. */
-export declare type DefaultCognitiveServicesAccount = BaseCognitiveServicesAccount & {
+/** An empty object that represents the default Azure AI service resource for a skillset. */
+export declare interface DefaultCognitiveServicesAccount extends BaseCognitiveServicesAccount {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.DefaultCognitiveServices";
-};
+}
 
 /**
  * Options for delete alias operation.
@@ -989,7 +995,7 @@ export declare interface DeleteSynonymMapOptions extends OperationOptions {
 }
 
 /** Decomposes compound words found in many Germanic languages. This token filter is implemented using Apache Lucene. */
-export declare type DictionaryDecompounderTokenFilter = BaseTokenFilter & {
+export declare interface DictionaryDecompounderTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.DictionaryDecompounderTokenFilter";
     /** The list of words to match against. */
@@ -1002,15 +1008,15 @@ export declare type DictionaryDecompounderTokenFilter = BaseTokenFilter & {
     maxSubwordSize?: number;
     /** A value indicating whether to add only the longest matching subword to the output. Default is false. */
     onlyLongestMatch?: boolean;
-};
+}
 
 /** Defines a function that boosts scores based on distance from a geographic location. */
-export declare type DistanceScoringFunction = BaseScoringFunction & {
+export declare interface DistanceScoringFunction extends BaseScoringFunction {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     type: "distance";
     /** Parameter values for the distance scoring function. */
     parameters: DistanceScoringParameters;
-};
+}
 
 /** Provides parameter values to a distance scoring function. */
 export declare interface DistanceScoringParameters {
@@ -1030,7 +1036,7 @@ export declare interface DocumentDebugInfo {
 }
 
 /** A skill that extracts content from a file within the enrichment pipeline. */
-export declare type DocumentExtractionSkill = BaseSearchIndexerSkill & {
+export declare interface DocumentExtractionSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Util.DocumentExtractionSkill";
     /** The parsingMode for the skill. Will be set to 'default' if not defined. */
@@ -1041,7 +1047,7 @@ export declare type DocumentExtractionSkill = BaseSearchIndexerSkill & {
     configuration?: {
         [propertyName: string]: any;
     };
-};
+}
 
 /**
  * Generates n-grams of the given size(s) starting from the front or the back of an input token.
@@ -1078,7 +1084,7 @@ export declare interface EdgeNGramTokenFilter {
 export declare type EdgeNGramTokenFilterSide = "front" | "back";
 
 /** Tokenizes the input from an edge into n-grams of the given size(s). This tokenizer is implemented using Apache Lucene. */
-export declare type EdgeNGramTokenizer = BaseLexicalTokenizer & {
+export declare interface EdgeNGramTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.EdgeNGramTokenizer";
     /** The minimum n-gram length. Default is 1. Maximum is 300. Must be less than the value of maxGram. */
@@ -1087,49 +1093,36 @@ export declare type EdgeNGramTokenizer = BaseLexicalTokenizer & {
     maxGram?: number;
     /** Character classes to keep in the tokens. */
     tokenChars?: TokenCharacterKind[];
-};
+}
 
 /** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). This token filter is implemented using Apache Lucene. */
-export declare type ElisionTokenFilter = BaseTokenFilter & {
+export declare interface ElisionTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.ElisionTokenFilter";
     /** The set of articles to remove. */
     articles?: string[];
-};
+}
 
-/**
- * Defines values for EntityCategory. \
- * {@link KnownEntityCategory} can be used interchangeably with EntityCategory,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **location**: Entities describing a physical location. \
- * **organization**: Entities describing an organization. \
- * **person**: Entities describing a person. \
- * **quantity**: Entities describing a quantity. \
- * **datetime**: Entities describing a date and time. \
- * **url**: Entities describing a URL. \
- * **email**: Entities describing an email address.
- */
-export declare type EntityCategory = string;
+export declare type EntityCategory = "location" | "organization" | "person" | "quantity" | "datetime" | "url" | "email";
 
 /** Using the Text Analytics API, extracts linked entities from text. */
-export declare type EntityLinkingSkill = BaseSearchIndexerSkill & {
+export declare interface EntityLinkingSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.V3.EntityLinkingSkill";
-    /** A value indicating which language code to use. Default is en. */
+    /** A value indicating which language code to use. Default is `en`. */
     defaultLanguageCode?: string;
     /** A value between 0 and 1 that be used to only include entities whose confidence score is greater than the value specified. If not set (default), or if explicitly set to null, all entities will be included. */
     minimumPrecision?: number;
     /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
-};
+}
 
 /**
- * This skill is deprecated. Use the V3.EntityRecognitionSkill instead.
+ * Text analytics entity recognition.
  *
- * @deprecated
+ * @deprecated This skill has been deprecated.
  */
-export declare type EntityRecognitionSkill = BaseSearchIndexerSkill & {
+export declare interface EntityRecognitionSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.EntityRecognitionSkill";
     /** A list of entity categories that should be extracted. */
@@ -1140,73 +1133,66 @@ export declare type EntityRecognitionSkill = BaseSearchIndexerSkill & {
     includeTypelessEntities?: boolean;
     /** A value between 0 and 1 that be used to only include entities whose confidence score is greater than the value specified. If not set (default), or if explicitly set to null, all entities will be included. */
     minimumPrecision?: number;
-};
+}
 
-/**
- * Defines values for EntityRecognitionSkillLanguage. \
- * {@link KnownEntityRecognitionSkillLanguage} can be used interchangeably with EntityRecognitionSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **ar**: Arabic \
- * **cs**: Czech \
- * **zh-Hans**: Chinese-Simplified \
- * **zh-Hant**: Chinese-Traditional \
- * **da**: Danish \
- * **nl**: Dutch \
- * **en**: English \
- * **fi**: Finnish \
- * **fr**: French \
- * **de**: German \
- * **el**: Greek \
- * **hu**: Hungarian \
- * **it**: Italian \
- * **ja**: Japanese \
- * **ko**: Korean \
- * **no**: Norwegian (Bokmaal) \
- * **pl**: Polish \
- * **pt-PT**: Portuguese (Portugal) \
- * **pt-BR**: Portuguese (Brazil) \
- * **ru**: Russian \
- * **es**: Spanish \
- * **sv**: Swedish \
- * **tr**: Turkish
- */
-export declare type EntityRecognitionSkillLanguage = string;
+export declare type EntityRecognitionSkillLanguage = "ar" | "cs" | "zh-Hans" | "zh-Hant" | "da" | "nl" | "en" | "fi" | "fr" | "de" | "el" | "hu" | "it" | "ja" | "ko" | "no" | "pl" | "pt-PT" | "pt-BR" | "ru" | "es" | "sv" | "tr";
 
 /** Using the Text Analytics API, extracts entities of different types from text. */
-export declare type EntityRecognitionSkillV3 = BaseSearchIndexerSkill & {
+export declare interface EntityRecognitionSkillV3 extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.V3.EntityRecognitionSkill";
     /** A list of entity categories that should be extracted. */
     categories?: string[];
-    /** A value indicating which language code to use. Default is en. */
+    /** A value indicating which language code to use. Default is `en`. */
     defaultLanguageCode?: string;
     /** A value between 0 and 1 that be used to only include entities whose confidence score is greater than the value specified. If not set (default), or if explicitly set to null, all entities will be included. */
     minimumPrecision?: number;
-    /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
+    /** The version of the model to use when calling the Text Analytics API. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
-};
+}
 
 export declare type ExcludedODataTypes = Date | GeographyPoint;
 
-/** Contains the parameters specific to exhaustive KNN algorithm. */
-export declare interface ExhaustiveKnnParameters {
-    /** The similarity metric to use for vector comparisons. */
-    metric?: VectorSearchAlgorithmMetric;
-}
-
 /** Contains configuration options specific to the exhaustive KNN algorithm used during querying, which will perform brute-force search across the entire vector index. */
-export declare type ExhaustiveKnnVectorSearchAlgorithmConfiguration = BaseVectorSearchAlgorithmConfiguration & {
+export declare type ExhaustiveKnnAlgorithmConfiguration = BaseVectorSearchAlgorithmConfiguration & {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     kind: "exhaustiveKnn";
     /** Contains the parameters specific to exhaustive KNN algorithm. */
     parameters?: ExhaustiveKnnParameters;
 };
 
+/** Contains the parameters specific to exhaustive KNN algorithm. */
+export declare interface ExhaustiveKnnParameters {
+    /** The similarity metric to use for vector comparisons. */
+    metric?: VectorSearchAlgorithmMetric;
+}
+
 export declare type ExtractDocumentKey<TModel> = {
     [K in keyof TModel as TModel[K] extends string | undefined ? K : never]: TModel[K];
 };
 
+/**
+ * Extracts answer candidates from the contents of the documents returned in response to a query
+ * expressed as a question in natural language.
+ */
+export declare interface ExtractiveQueryAnswer {
+    answerType: "extractive";
+    /**
+     * The number of answers returned. Default count is 1
+     */
+    count?: number;
+    /**
+     * The confidence threshold. Default threshold is 0.7
+     */
+    threshold?: number;
+}
+
+/** Extracts captions from the matching documents that contain passages relevant to the search query. */
+export declare interface ExtractiveQueryCaption {
+    captionType: "extractive";
+    highlight?: boolean;
+}
+
 /** A single bucket of a facet query result. Reports the number of documents with a field value falling within a particular range or having a particular value or interval. */
 export declare interface FacetResult {
     /** Describes unknown properties. The value of an unknown property can be of "any" type. */
@@ -1239,12 +1225,12 @@ export declare interface FieldMappingFunction {
 }
 
 /** Defines a function that boosts scores based on the value of a date-time field. */
-export declare type FreshnessScoringFunction = BaseScoringFunction & {
+export declare interface FreshnessScoringFunction extends BaseScoringFunction {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     type: "freshness";
     /** Parameter values for the freshness scoring function. */
     parameters: FreshnessScoringParameters;
-};
+}
 
 /** Provides parameter values to a freshness scoring function. */
 export declare interface FreshnessScoringParameters {
@@ -1336,11 +1322,27 @@ export declare type GetSkillSetOptions = OperationOptions;
 export declare type GetSynonymMapsOptions = OperationOptions;
 
 /** Defines a data change detection policy that captures changes based on the value of a high water mark column. */
-export declare type HighWaterMarkChangeDetectionPolicy = BaseDataChangeDetectionPolicy & {
+export declare interface HighWaterMarkChangeDetectionPolicy extends BaseDataChangeDetectionPolicy {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy";
     /** The name of the high water mark column. */
     highWaterMarkColumnName: string;
+}
+
+/**
+ * Contains configuration options specific to the hnsw approximate nearest neighbors algorithm
+ * used during indexing time.
+ */
+export declare type HnswAlgorithmConfiguration = BaseVectorSearchAlgorithmConfiguration & {
+    /**
+     * Polymorphic discriminator, which specifies the different types this object can be
+     */
+    kind: "hnsw";
+    /**
+     * Contains the parameters specific to hnsw algorithm.
+     *
+     */
+    parameters?: HnswParameters;
 };
 
 /**
@@ -1372,24 +1374,20 @@ export declare interface HnswParameters {
     metric?: VectorSearchAlgorithmMetric;
 }
 
-/**
- * Contains configuration options specific to the hnsw approximate nearest neighbors algorithm
- * used during indexing time.
- */
-export declare type HnswVectorSearchAlgorithmConfiguration = BaseVectorSearchAlgorithmConfiguration & {
-    /**
-     * Polymorphic discriminator, which specifies the different types this object can be
-     */
-    kind: "hnsw";
-    /**
-     * Contains the parameters specific to hnsw algorithm.
-     *
-     */
-    parameters?: HnswParameters;
-};
+/** A skill that analyzes image files. It extracts a rich set of visual features based on the image content. */
+export declare interface ImageAnalysisSkill extends BaseSearchIndexerSkill {
+    /** Polymorphic discriminator, which specifies the different types this object can be */
+    odatatype: "#Microsoft.Skills.Vision.ImageAnalysisSkill";
+    /** A value indicating which language code to use. Default is en. */
+    defaultLanguageCode?: ImageAnalysisSkillLanguage;
+    /** A list of visual features. */
+    visualFeatures?: VisualFeature[];
+    /** A string indicating which domain-specific details to return. */
+    details?: ImageDetail[];
+}
 
 /** A skill that analyzes image files. It extracts a rich set of visual features based on the image content. */
-export declare type ImageAnalysisSkill = BaseSearchIndexerSkill & {
+export declare interface ImageAnalysisSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Vision.ImageAnalysisSkill";
     /** A value indicating which language code to use. Default is en. */
@@ -1398,77 +1396,11 @@ export declare type ImageAnalysisSkill = BaseSearchIndexerSkill & {
     visualFeatures?: VisualFeature[];
     /** A string indicating which domain-specific details to return. */
     details?: ImageDetail[];
-};
+}
 
-/**
- * Defines values for ImageAnalysisSkillLanguage. \
- * {@link KnownImageAnalysisSkillLanguage} can be used interchangeably with ImageAnalysisSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **ar**: Arabic \
- * **az**: Azerbaijani \
- * **bg**: Bulgarian \
- * **bs**: Bosnian Latin \
- * **ca**: Catalan \
- * **cs**: Czech \
- * **cy**: Welsh \
- * **da**: Danish \
- * **de**: German \
- * **el**: Greek \
- * **en**: English \
- * **es**: Spanish \
- * **et**: Estonian \
- * **eu**: Basque \
- * **fi**: Finnish \
- * **fr**: French \
- * **ga**: Irish \
- * **gl**: Galician \
- * **he**: Hebrew \
- * **hi**: Hindi \
- * **hr**: Croatian \
- * **hu**: Hungarian \
- * **id**: Indonesian \
- * **it**: Italian \
- * **ja**: Japanese \
- * **kk**: Kazakh \
- * **ko**: Korean \
- * **lt**: Lithuanian \
- * **lv**: Latvian \
- * **mk**: Macedonian \
- * **ms**: Malay Malaysia \
- * **nb**: Norwegian (Bokmal) \
- * **nl**: Dutch \
- * **pl**: Polish \
- * **prs**: Dari \
- * **pt-BR**: Portuguese-Brazil \
- * **pt**: Portuguese-Portugal \
- * **pt-PT**: Portuguese-Portugal \
- * **ro**: Romanian \
- * **ru**: Russian \
- * **sk**: Slovak \
- * **sl**: Slovenian \
- * **sr-Cyrl**: Serbian - Cyrillic RS \
- * **sr-Latn**: Serbian - Latin RS \
- * **sv**: Swedish \
- * **th**: Thai \
- * **tr**: Turkish \
- * **uk**: Ukrainian \
- * **vi**: Vietnamese \
- * **zh**: Chinese Simplified \
- * **zh-Hans**: Chinese Simplified \
- * **zh-Hant**: Chinese Traditional
- */
-export declare type ImageAnalysisSkillLanguage = string;
-
-/**
- * Defines values for ImageDetail. \
- * {@link KnownImageDetail} can be used interchangeably with ImageDetail,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **celebrities**: Details recognized as celebrities. \
- * **landmarks**: Details recognized as landmarks.
- */
-export declare type ImageDetail = string;
+export declare type ImageAnalysisSkillLanguage = "ar" | "az" | "bg" | "bs" | "ca" | "cs" | "cy" | "da" | "de" | "el" | "en" | "es" | "et" | "eu" | "fi" | "fr" | "ga" | "gl" | "he" | "hi" | "hr" | "hu" | "id" | "it" | "ja" | "kk" | "ko" | "lt" | "lv" | "mk" | "ms" | "nb" | "nl" | "pl" | "prs" | "pt-BR" | "pt" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr-Cyrl" | "sr-Latn" | "sv" | "th" | "tr" | "uk" | "vi" | "zh" | "zh-Hans" | "zh-Hant";
+
+export declare type ImageDetail = "celebrities" | "landmarks";
 
 /** Defines values for IndexActionType. */
 export declare type IndexActionType = "upload" | "merge" | "mergeOrUpload" | "delete";
@@ -1476,58 +1408,58 @@ export declare type IndexActionType = "upload" | "merge" | "mergeOrUpload" | "de
 /**
  * Represents an index action that operates on a document.
  */
-export declare type IndexDocumentsAction<T> = {
+export declare type IndexDocumentsAction<TModel> = {
     /**
      * The operation to perform on a document in an indexing batch. Possible values include:
      * 'upload', 'merge', 'mergeOrUpload', 'delete'
      */
     __actionType: IndexActionType;
-} & Partial<T>;
+} & Partial<TModel>;
 
 /**
  * Class used to perform batch operations
  * with multiple documents to the index.
  */
-export declare class IndexDocumentsBatch<T> {
+export declare class IndexDocumentsBatch<TModel> {
     /**
      * The set of actions taken in this batch.
      */
-    readonly actions: IndexDocumentsAction<T>[];
-    constructor(actions?: IndexDocumentsAction<T>[]);
+    readonly actions: IndexDocumentsAction<TModel>[];
+    constructor(actions?: IndexDocumentsAction<TModel>[]);
     /**
      * Upload an array of documents to the index.
      * @param documents - The documents to upload.
      */
-    upload(documents: T[]): void;
+    upload(documents: TModel[]): void;
     /**
      * Update a set of documents in the index.
      * For more details about how merging works, see https://docs.microsoft.com/en-us/rest/api/searchservice/AddUpdate-or-Delete-Documents
      * @param documents - The updated documents.
      */
-    merge(documents: T[]): void;
+    merge(documents: TModel[]): void;
     /**
      * Update a set of documents in the index or uploads them if they don't exist.
      * For more details about how merging works, see https://docs.microsoft.com/en-us/rest/api/searchservice/AddUpdate-or-Delete-Documents
      * @param documents - The new/updated documents.
      */
-    mergeOrUpload(documents: T[]): void;
+    mergeOrUpload(documents: TModel[]): void;
     /**
      * Delete a set of documents.
      * @param keyName - The name of their primary key in the index.
      * @param keyValues - The primary key values of documents to delete.
      */
-    delete(keyName: keyof T, keyValues: string[]): void;
+    delete(keyName: keyof TModel, keyValues: string[]): void;
     /**
      * Delete a set of documents.
      * @param documents - Documents to be deleted.
      */
-    delete(documents: T[]): void;
+    delete(documents: TModel[]): void;
 }
 
 /**
  * Index Documents Client
  */
-export declare interface IndexDocumentsClient<T extends object> {
+export declare interface IndexDocumentsClient<TModel extends object> {
     /**
      * Perform a set of index modifications (upload, merge, mergeOrUpload, delete)
      * for the given set of documents.
@@ -1535,7 +1467,7 @@ export declare interface IndexDocumentsClient<T extends object> {
      * @param batch - An array of actions to perform on the index.
      * @param options - Additional options.
      */
-    indexDocuments(batch: IndexDocumentsBatch<T>, options: IndexDocumentsOptions): Promise<IndexDocumentsResult>;
+    indexDocuments(batch: IndexDocumentsBatch<TModel>, options: IndexDocumentsOptions): Promise<IndexDocumentsResult>;
 }
 
 /**
@@ -1558,15 +1490,7 @@ export declare interface IndexDocumentsResult {
     readonly results: IndexingResult[];
 }
 
-/**
- * Defines values for IndexerExecutionEnvironment. \
- * {@link KnownIndexerExecutionEnvironment} can be used interchangeably with IndexerExecutionEnvironment,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **standard**: Indicates that Azure Cognitive Search can determine where the indexer should execute. This is the default environment when nothing is specified and is the recommended value. \
- * **private**: Indicates that the indexer should run with the environment provisioned specifically for the search service. This should only be specified as the execution environment if the indexer needs to access resources securely over shared private link resources.
- */
-export declare type IndexerExecutionEnvironment = string;
+export declare type IndexerExecutionEnvironment = "standard" | "private";
 
 /** Represents the result of an individual indexer execution. */
 export declare interface IndexerExecutionResult {
@@ -1793,9 +1717,14 @@ export declare type IndexIterator = PagedAsyncIterableIterator<SearchIndex, Sear
 export declare type IndexNameIterator = PagedAsyncIterableIterator<string, string[], {}>;
 
 /**
- * Defines behavior of the index projections in relation to the rest of the indexer.
+ * Defines values for IndexProjectionMode. \
+ * {@link KnownIndexProjectionMode} can be used interchangeably with IndexProjectionMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **skipIndexingParentDocuments**: The source document will be skipped from writing into the indexer's target index. \
+ * **includeIndexingParentDocuments**: The source document will be written into the indexer's target index. This is the default pattern.
  */
-export declare type IndexProjectionMode = "skipIndexingParentDocuments" | "includeIndexingParentDocuments";
+export declare type IndexProjectionMode = string;
 
 /** Input field mapping for a skill. */
 export declare interface InputFieldMappingEntry {
@@ -1810,17 +1739,17 @@ export declare interface InputFieldMappingEntry {
 }
 
 /** A token filter that only keeps tokens with text contained in a specified list of words. This token filter is implemented using Apache Lucene. */
-export declare type KeepTokenFilter = BaseTokenFilter & {
+export declare interface KeepTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.KeepTokenFilter";
     /** The list of words to keep. */
     keepWords: string[];
     /** A value indicating whether to lower case all words first. Default is false. */
     lowerCaseKeepWords?: boolean;
-};
+}
 
 /** A skill that uses text analytics for key phrase extraction. */
-export declare type KeyPhraseExtractionSkill = BaseSearchIndexerSkill & {
+export declare interface KeyPhraseExtractionSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.KeyPhraseExtractionSkill";
     /** A value indicating which language code to use. Default is en. */
@@ -1829,41 +1758,19 @@ export declare type KeyPhraseExtractionSkill = BaseSearchIndexerSkill & {
     maxKeyPhraseCount?: number;
     /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
-};
+}
 
-/**
- * Defines values for KeyPhraseExtractionSkillLanguage. \
- * {@link KnownKeyPhraseExtractionSkillLanguage} can be used interchangeably with KeyPhraseExtractionSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **da**: Danish \
- * **nl**: Dutch \
- * **en**: English \
- * **fi**: Finnish \
- * **fr**: French \
- * **de**: German \
- * **it**: Italian \
- * **ja**: Japanese \
- * **ko**: Korean \
- * **no**: Norwegian (Bokmaal) \
- * **pl**: Polish \
- * **pt-PT**: Portuguese (Portugal) \
- * **pt-BR**: Portuguese (Brazil) \
- * **ru**: Russian \
- * **es**: Spanish \
- * **sv**: Swedish
- */
-export declare type KeyPhraseExtractionSkillLanguage = string;
+export declare type KeyPhraseExtractionSkillLanguage = "da" | "nl" | "en" | "fi" | "fr" | "de" | "it" | "ja" | "ko" | "no" | "pl" | "pt-PT" | "pt-BR" | "ru" | "es" | "sv";
 
 /** Marks terms as keywords. This token filter is implemented using Apache Lucene. */
-export declare type KeywordMarkerTokenFilter = BaseTokenFilter & {
+export declare interface KeywordMarkerTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.KeywordMarkerTokenFilter";
     /** A list of words to mark as keywords. */
     keywords: string[];
     /** A value indicating whether to ignore case. If true, all words are converted to lower case first. Default is false. */
     ignoreCase?: boolean;
-};
+}
 
 /**
  * Emits the entire input as a single token. This tokenizer is implemented using Apache Lucene.
@@ -2265,14 +2172,6 @@ export declare enum KnownAnalyzerNames {
     Whitespace = "whitespace"
 }
 
-/** Known values of {@link Answers} that the service accepts. */
-export declare enum KnownAnswers {
-    /** Do not return answers for the query. */
-    None = "none",
-    /** Extracts answer candidates from the contents of the documents returned in response to a query expressed as a question in natural language. */
-    Extractive = "extractive"
-}
-
 /** Known values of {@link BlobIndexerDataToExtract} that the service accepts. */
 export declare enum KnownBlobIndexerDataToExtract {
     /** Indexes just the standard blob properties and user-specified metadata. */
@@ -2303,9 +2202,9 @@ export declare enum KnownBlobIndexerParsingMode {
     DelimitedText = "delimitedText",
     /** Set to json to extract structured content from JSON files. */
     Json = "json",
-    /** Set to jsonArray to extract individual elements of a JSON array as separate documents in Azure Cognitive Search. */
+    /** Set to jsonArray to extract individual elements of a JSON array as separate documents. */
     JsonArray = "jsonArray",
-    /** Set to jsonLines to extract individual JSON entities, separated by a new line, as separate documents in Azure Cognitive Search. */
+    /** Set to jsonLines to extract individual JSON entities, separated by a new line, as separate documents. */
     JsonLines = "jsonLines"
 }
 
@@ -2319,7 +2218,7 @@ export declare enum KnownBlobIndexerPDFTextRotationAlgorithm {
 
 /** Known values of {@link CharFilterName} that the service accepts. */
 export declare enum KnownCharFilterName {
-    /** A character filter that attempts to strip out HTML constructs. See https://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/charfilter/HTMLStripCharFilter.html */
+    /** A character filter that attempts to strip out HTML constructs. See https:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/charfilter\/HTMLStripCharFilter.html */
     HtmlStrip = "html_strip"
 }
 
@@ -2541,6 +2440,14 @@ export declare enum KnownImageDetail {
     Landmarks = "landmarks"
 }
 
+/** Known values of {@link IndexerExecutionEnvironment} that the service accepts. */
+export declare enum KnownIndexerExecutionEnvironment {
+    /** Indicates that the search service can determine where the indexer should execute. This is the default environment when nothing is specified and is the recommended value. */
+    Standard = "standard",
+    /** Indicates that the indexer should run with the environment provisioned specifically for the search service. This should only be specified as the execution environment if the indexer needs to access resources securely over shared private link resources. */
+    Private = "private"
+}
+
 /** Known values of {@link IndexerExecutionStatusDetail} that the service accepts. */
 export declare enum KnownIndexerExecutionStatusDetail {
     /** Indicates that the reset that occurred was for a call to ResetDocs. */
@@ -2555,6 +2462,14 @@ export declare enum KnownIndexingMode {
     IndexingResetDocs = "indexingResetDocs"
 }
 
+/** Known values of {@link IndexProjectionMode} that the service accepts. */
+export declare enum KnownIndexProjectionMode {
+    /** The source document will be skipped from writing into the indexer's target index. */
+    SkipIndexingParentDocuments = "skipIndexingParentDocuments",
+    /** The source document will be written into the indexer's target index. This is the default pattern. */
+    IncludeIndexingParentDocuments = "includeIndexingParentDocuments"
+}
+
 /** Known values of {@link KeyPhraseExtractionSkillLanguage} that the service accepts. */
 export declare enum KnownKeyPhraseExtractionSkillLanguage {
     /** Danish */
@@ -2767,33 +2682,65 @@ export declare enum KnownLexicalAnalyzerName {
     ViMicrosoft = "vi.microsoft",
     /** Standard Lucene analyzer. */
     StandardLucene = "standard.lucene",
-    /** Standard ASCII Folding Lucene analyzer. See https://docs.microsoft.com/rest/api/searchservice/Custom-analyzers-in-Azure-Search#Analyzers */
+    /** Standard ASCII Folding Lucene analyzer. See https:\//docs.microsoft.com\/rest\/api\/searchservice\/Custom-analyzers-in-Azure-Search#Analyzers */
     StandardAsciiFoldingLucene = "standardasciifolding.lucene",
-    /** Treats the entire content of a field as a single token. This is useful for data like zip codes, ids, and some product names. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/KeywordAnalyzer.html */
+    /** Treats the entire content of a field as a single token. This is useful for data like zip codes, ids, and some product names. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/KeywordAnalyzer.html */
     Keyword = "keyword",
-    /** Flexibly separates text into terms via a regular expression pattern. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/PatternAnalyzer.html */
+    /** Flexibly separates text into terms via a regular expression pattern. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/PatternAnalyzer.html */
     Pattern = "pattern",
-    /** Divides text at non-letters and converts them to lower case. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/SimpleAnalyzer.html */
+    /** Divides text at non-letters and converts them to lower case. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/SimpleAnalyzer.html */
     Simple = "simple",
-    /** Divides text at non-letters; Applies the lowercase and stopword token filters. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/StopAnalyzer.html */
+    /** Divides text at non-letters; Applies the lowercase and stopword token filters. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/StopAnalyzer.html */
     Stop = "stop",
-    /** An analyzer that uses the whitespace tokenizer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/WhitespaceAnalyzer.html */
+    /** An analyzer that uses the whitespace tokenizer. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/WhitespaceAnalyzer.html */
     Whitespace = "whitespace"
 }
 
 /** Known values of {@link LexicalNormalizerName} that the service accepts. */
-export declare enum KnownLexicalNormalizerName {
-    /** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ASCIIFoldingFilter.html */
+declare enum KnownLexicalNormalizerName {
+    /** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/ASCIIFoldingFilter.html */
     AsciiFolding = "asciifolding",
-    /** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/util/ElisionFilter.html */
+    /** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/util\/ElisionFilter.html */
     Elision = "elision",
-    /** Normalizes token text to lowercase. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/LowerCaseFilter.html */
+    /** Normalizes token text to lowercase. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LowerCaseFilter.html */
     Lowercase = "lowercase",
-    /** Standard normalizer, which consists of lowercase and asciifolding. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/reverse/ReverseStringFilter.html */
+    /** Standard normalizer, which consists of lowercase and asciifolding. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/reverse\/ReverseStringFilter.html */
     Standard = "standard",
-    /** Normalizes token text to uppercase. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/UpperCaseFilter.html */
+    /** Normalizes token text to uppercase. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/UpperCaseFilter.html */
     Uppercase = "uppercase"
 }
+export { KnownLexicalNormalizerName }
+export { KnownLexicalNormalizerName as KnownNormalizerNames }
+
+/** Known values of {@link LexicalTokenizerName} that the service accepts. */
+export declare enum KnownLexicalTokenizerName {
+    /** Grammar-based tokenizer that is suitable for processing most European-language documents. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/ClassicTokenizer.html */
+    Classic = "classic",
+    /** Tokenizes the input from an edge into n-grams of the given size(s). See https:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/EdgeNGramTokenizer.html */
+    EdgeNGram = "edgeNGram",
+    /** Emits the entire input as a single token. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/KeywordTokenizer.html */
+    Keyword = "keyword_v2",
+    /** Divides text at non-letters. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LetterTokenizer.html */
+    Letter = "letter",
+    /** Divides text at non-letters and converts them to lower case. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LowerCaseTokenizer.html */
+    Lowercase = "lowercase",
+    /** Divides text using language-specific rules. */
+    MicrosoftLanguageTokenizer = "microsoft_language_tokenizer",
+    /** Divides text using language-specific rules and reduces words to their base forms. */
+    MicrosoftLanguageStemmingTokenizer = "microsoft_language_stemming_tokenizer",
+    /** Tokenizes the input into n-grams of the given size(s). See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/NGramTokenizer.html */
+    NGram = "nGram",
+    /** Tokenizer for path-like hierarchies. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/path\/PathHierarchyTokenizer.html */
+    PathHierarchy = "path_hierarchy_v2",
+    /** Tokenizer that uses regex pattern matching to construct distinct tokens. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/pattern\/PatternTokenizer.html */
+    Pattern = "pattern",
+    /** Standard Lucene analyzer; Composed of the standard tokenizer, lowercase filter and stop filter. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/StandardTokenizer.html */
+    Standard = "standard_v2",
+    /** Tokenizes urls and emails as one token. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/UAX29URLEmailTokenizer.html */
+    UaxUrlEmail = "uax_url_email",
+    /** Divides text at whitespace. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/WhitespaceTokenizer.html */
+    Whitespace = "whitespace"
+}
 
 /** Known values of {@link LineEnding} that the service accepts. */
 export declare enum KnownLineEnding {
@@ -3159,20 +3106,12 @@ export declare enum KnownPIIDetectionSkillMaskingMode {
     Replace = "replace"
 }
 
-/** Known values of {@link QueryAnswerType} that the service accepts. */
-export declare enum KnownQueryAnswerType {
-    /** Do not return answers for the query. */
-    None = "none",
-    /** Extracts answer candidates from the contents of the documents returned in response to a query expressed as a question in natural language. */
-    Extractive = "extractive"
-}
-
-/** Known values of {@link QueryCaptionType} that the service accepts. */
-export declare enum KnownQueryCaptionType {
-    /** Do not return captions for the query. */
-    None = "none",
-    /** Extracts captions from the matching documents that contain passages relevant to the search query. */
-    Extractive = "extractive"
+/** Known values of {@link QueryDebugMode} that the service accepts. */
+export declare enum KnownQueryDebugMode {
+    /** No query debugging information will be returned. */
+    Disabled = "disabled",
+    /** Allows the user to further explore their reranked results. */
+    Semantic = "semantic"
 }
 
 /** Known values of {@link QueryLanguage} that the service accepts. */
@@ -3279,7 +3218,7 @@ export declare enum KnownQueryLanguage {
     LvLv = "lv-lv",
     /** Query language value for Estonian (Estonia). */
     EtEe = "et-ee",
-    /** Query language value for Catalan (Spain). */
+    /** Query language value for Catalan. */
     CaEs = "ca-es",
     /** Query language value for Finnish (Finland). */
     FiFi = "fi-fi",
@@ -3297,9 +3236,9 @@ export declare enum KnownQueryLanguage {
     HyAm = "hy-am",
     /** Query language value for Bengali (India). */
     BnIn = "bn-in",
-    /** Query language value for Basque (Spain). */
+    /** Query language value for Basque. */
     EuEs = "eu-es",
-    /** Query language value for Galician (Spain). */
+    /** Query language value for Galician. */
     GlEs = "gl-es",
     /** Query language value for Gujarati (India). */
     GuIn = "gu-in",
@@ -3385,6 +3324,42 @@ export declare enum KnownSearchIndexerDataSourceType {
     AdlsGen2 = "adlsgen2"
 }
 
+/** Known values of {@link SemanticErrorMode} that the service accepts. */
+export declare enum KnownSemanticErrorMode {
+    /** If the semantic processing fails, partial results still return. The definition of partial results depends on what semantic step failed and what was the reason for failure. */
+    Partial = "partial",
+    /** If there is an exception during the semantic processing step, the query will fail and return the appropriate HTTP code depending on the error. */
+    Fail = "fail"
+}
+
+/** Known values of {@link SemanticErrorReason} that the service accepts. */
+export declare enum KnownSemanticErrorReason {
+    /** If 'semanticMaxWaitInMilliseconds' was set and the semantic processing duration exceeded that value. Only the base results were returned. */
+    MaxWaitExceeded = "maxWaitExceeded",
+    /** The request was throttled. Only the base results were returned. */
+    CapacityOverloaded = "capacityOverloaded",
+    /** At least one step of the semantic process failed. */
+    Transient = "transient"
+}
+
+/** Known values of {@link SemanticFieldState} that the service accepts. */
+export declare enum KnownSemanticFieldState {
+    /** The field was fully used for semantic enrichment. */
+    Used = "used",
+    /** The field was not used for semantic enrichment. */
+    Unused = "unused",
+    /** The field was partially used for semantic enrichment. */
+    Partial = "partial"
+}
+
+/** Known values of {@link SemanticSearchResultsType} that the service accepts. */
+export declare enum KnownSemanticSearchResultsType {
+    /** Results without any semantic enrichment or reranking. */
+    BaseResults = "baseResults",
+    /** Results have been reranked with the reranker model and will include semantic captions. They will not include any answers, answers highlights or caption highlights. */
+    RerankedResults = "rerankedResults"
+}
+
 /** Known values of {@link SentimentSkillLanguage} that the service accepts. */
 export declare enum KnownSentimentSkillLanguage {
     /** Danish */
@@ -3429,6 +3404,12 @@ export declare enum KnownSpeller {
 
 /** Known values of {@link SplitSkillLanguage} that the service accepts. */
 export declare enum KnownSplitSkillLanguage {
+    /** Amharic */
+    Am = "am",
+    /** Bosnian */
+    Bs = "bs",
+    /** Czech */
+    Cs = "cs",
     /** Danish */
     Da = "da",
     /** German */
@@ -3437,16 +3418,58 @@ export declare enum KnownSplitSkillLanguage {
     En = "en",
     /** Spanish */
     Es = "es",
+    /** Estonian */
+    Et = "et",
     /** Finnish */
     Fi = "fi",
     /** French */
     Fr = "fr",
+    /** Hebrew */
+    He = "he",
+    /** Hindi */
+    Hi = "hi",
+    /** Croatian */
+    Hr = "hr",
+    /** Hungarian */
+    Hu = "hu",
+    /** Indonesian */
+    Id = "id",
+    /** Icelandic */
+    Is = "is",
     /** Italian */
     It = "it",
+    /** Japanese */
+    Ja = "ja",
     /** Korean */
     Ko = "ko",
-    /** Portuguese */
-    Pt = "pt"
+    /** Latvian */
+    Lv = "lv",
+    /** Norwegian */
+    Nb = "nb",
+    /** Dutch */
+    Nl = "nl",
+    /** Polish */
+    Pl = "pl",
+    /** Portuguese (Portugal) */
+    Pt = "pt",
+    /** Portuguese (Brazil) */
+    PtBr = "pt-br",
+    /** Russian */
+    Ru = "ru",
+    /** Slovak */
+    Sk = "sk",
+    /** Slovenian */
+    Sl = "sl",
+    /** Serbian */
+    Sr = "sr",
+    /** Swedish */
+    Sv = "sv",
+    /** Turkish */
+    Tr = "tr",
+    /** Urdu */
+    Ur = "ur",
+    /** Chinese (Simplified) */
+    Zh = "zh"
 }
 
 /** Known values of {@link TextSplitMode} that the service accepts. */
@@ -3607,71 +3630,71 @@ export declare enum KnownTextTranslationSkillLanguage {
 
 /** Known values of {@link TokenFilterName} that the service accepts. */
 export declare enum KnownTokenFilterName {
-    /** A token filter that applies the Arabic normalizer to normalize the orthography. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ar/ArabicNormalizationFilter.html */
+    /** A token filter that applies the Arabic normalizer to normalize the orthography. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ar\/ArabicNormalizationFilter.html */
     ArabicNormalization = "arabic_normalization",
-    /** Strips all characters after an apostrophe (including the apostrophe itself). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/tr/ApostropheFilter.html */
+    /** Strips all characters after an apostrophe (including the apostrophe itself). See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/tr\/ApostropheFilter.html */
     Apostrophe = "apostrophe",
-    /** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ASCIIFoldingFilter.html */
+    /** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/ASCIIFoldingFilter.html */
     AsciiFolding = "asciifolding",
-    /** Forms bigrams of CJK terms that are generated from the standard tokenizer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/cjk/CJKBigramFilter.html */
+    /** Forms bigrams of CJK terms that are generated from the standard tokenizer. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/cjk\/CJKBigramFilter.html */
     CjkBigram = "cjk_bigram",
-    /** Normalizes CJK width differences. Folds fullwidth ASCII variants into the equivalent basic Latin, and half-width Katakana variants into the equivalent Kana. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/cjk/CJKWidthFilter.html */
+    /** Normalizes CJK width differences. Folds fullwidth ASCII variants into the equivalent basic Latin, and half-width Katakana variants into the equivalent Kana. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/cjk\/CJKWidthFilter.html */
     CjkWidth = "cjk_width",
-    /** Removes English possessives, and dots from acronyms. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/standard/ClassicFilter.html */
+    /** Removes English possessives, and dots from acronyms. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/ClassicFilter.html */
     Classic = "classic",
-    /** Construct bigrams for frequently occurring terms while indexing. Single terms are still indexed too, with bigrams overlaid. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/commongrams/CommonGramsFilter.html */
+    /** Construct bigrams for frequently occurring terms while indexing. Single terms are still indexed too, with bigrams overlaid. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/commongrams\/CommonGramsFilter.html */
     CommonGram = "common_grams",
-    /** Generates n-grams of the given size(s) starting from the front or the back of an input token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/EdgeNGramTokenFilter.html */
+    /** Generates n-grams of the given size(s) starting from the front or the back of an input token. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/EdgeNGramTokenFilter.html */
     EdgeNGram = "edgeNGram_v2",
-    /** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/util/ElisionFilter.html */
+    /** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/util\/ElisionFilter.html */
     Elision = "elision",
-    /** Normalizes German characters according to the heuristics of the German2 snowball algorithm. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/de/GermanNormalizationFilter.html */
+    /** Normalizes German characters according to the heuristics of the German2 snowball algorithm. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/de\/GermanNormalizationFilter.html */
     GermanNormalization = "german_normalization",
-    /** Normalizes text in Hindi to remove some differences in spelling variations. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/hi/HindiNormalizationFilter.html */
+    /** Normalizes text in Hindi to remove some differences in spelling variations. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/hi\/HindiNormalizationFilter.html */
     HindiNormalization = "hindi_normalization",
-    /** Normalizes the Unicode representation of text in Indian languages. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/in/IndicNormalizationFilter.html */
+    /** Normalizes the Unicode representation of text in Indian languages. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/in\/IndicNormalizationFilter.html */
     IndicNormalization = "indic_normalization",
-    /** Emits each incoming token twice, once as keyword and once as non-keyword. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/KeywordRepeatFilter.html */
+    /** Emits each incoming token twice, once as keyword and once as non-keyword. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/KeywordRepeatFilter.html */
     KeywordRepeat = "keyword_repeat",
-    /** A high-performance kstem filter for English. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/en/KStemFilter.html */
+    /** A high-performance kstem filter for English. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/en\/KStemFilter.html */
     KStem = "kstem",
-    /** Removes words that are too long or too short. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/LengthFilter.html */
+    /** Removes words that are too long or too short. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/LengthFilter.html */
     Length = "length",
-    /** Limits the number of tokens while indexing. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/LimitTokenCountFilter.html */
+    /** Limits the number of tokens while indexing. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/LimitTokenCountFilter.html */
     Limit = "limit",
-    /** Normalizes token text to lower case. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/LowerCaseFilter.html */
+    /** Normalizes token text to lower case. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LowerCaseFilter.html */
     Lowercase = "lowercase",
-    /** Generates n-grams of the given size(s). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/NGramTokenFilter.html */
+    /** Generates n-grams of the given size(s). See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/NGramTokenFilter.html */
     NGram = "nGram_v2",
-    /** Applies normalization for Persian. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/fa/PersianNormalizationFilter.html */
+    /** Applies normalization for Persian. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/fa\/PersianNormalizationFilter.html */
     PersianNormalization = "persian_normalization",
-    /** Create tokens for phonetic matches. See https://lucene.apache.org/core/4_10_3/analyzers-phonetic/org/apache/lucene/analysis/phonetic/package-tree.html */
+    /** Create tokens for phonetic matches. See https:\//lucene.apache.org\/core\/4_10_3\/analyzers-phonetic\/org\/apache\/lucene\/analysis\/phonetic\/package-tree.html */
     Phonetic = "phonetic",
-    /** Uses the Porter stemming algorithm to transform the token stream. See http://tartarus.org/~martin/PorterStemmer */
+    /** Uses the Porter stemming algorithm to transform the token stream. See http:\//tartarus.org\/~martin\/PorterStemmer */
     PorterStem = "porter_stem",
-    /** Reverses the token string. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/reverse/ReverseStringFilter.html */
+    /** Reverses the token string. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/reverse\/ReverseStringFilter.html */
     Reverse = "reverse",
-    /** Normalizes use of the interchangeable Scandinavian characters. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ScandinavianNormalizationFilter.html */
+    /** Normalizes use of the interchangeable Scandinavian characters. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/ScandinavianNormalizationFilter.html */
     ScandinavianNormalization = "scandinavian_normalization",
-    /** Folds Scandinavian characters åÅäæÄÆ-&gt;a and öÖøØ-&gt;o. It also discriminates against use of double vowels aa, ae, ao, oe and oo, leaving just the first one. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ScandinavianFoldingFilter.html */
+    /** Folds Scandinavian characters åÅäæÄÆ-&gt;a and öÖøØ-&gt;o. It also discriminates against use of double vowels aa, ae, ao, oe and oo, leaving just the first one. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/ScandinavianFoldingFilter.html */
     ScandinavianFoldingNormalization = "scandinavian_folding",
-    /** Creates combinations of tokens as a single token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/shingle/ShingleFilter.html */
+    /** Creates combinations of tokens as a single token. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/shingle\/ShingleFilter.html */
     Shingle = "shingle",
-    /** A filter that stems words using a Snowball-generated stemmer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/snowball/SnowballFilter.html */
+    /** A filter that stems words using a Snowball-generated stemmer. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/snowball\/SnowballFilter.html */
     Snowball = "snowball",
-    /** Normalizes the Unicode representation of Sorani text. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ckb/SoraniNormalizationFilter.html */
+    /** Normalizes the Unicode representation of Sorani text. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ckb\/SoraniNormalizationFilter.html */
     SoraniNormalization = "sorani_normalization",
-    /** Language specific stemming filter. See https://docs.microsoft.com/rest/api/searchservice/Custom-analyzers-in-Azure-Search#TokenFilters */
+    /** Language specific stemming filter. See https:\//docs.microsoft.com\/rest\/api\/searchservice\/Custom-analyzers-in-Azure-Search#TokenFilters */
     Stemmer = "stemmer",
-    /** Removes stop words from a token stream. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/StopFilter.html */
+    /** Removes stop words from a token stream. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/StopFilter.html */
     Stopwords = "stopwords",
-    /** Trims leading and trailing whitespace from tokens. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/TrimFilter.html */
+    /** Trims leading and trailing whitespace from tokens. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/TrimFilter.html */
     Trim = "trim",
-    /** Truncates the terms to a specific length. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/TruncateTokenFilter.html */
+    /** Truncates the terms to a specific length. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/TruncateTokenFilter.html */
     Truncate = "truncate",
-    /** Filters out tokens with same text as the previous token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/RemoveDuplicatesTokenFilter.html */
+    /** Filters out tokens with same text as the previous token. See http:\//lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/miscellaneous\/RemoveDuplicatesTokenFilter.html */
     Unique = "unique",
-    /** Normalizes token text to upper case. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/UpperCaseFilter.html */
+    /** Normalizes token text to upper case. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/UpperCaseFilter.html */
     Uppercase = "uppercase",
     /** Splits words into subwords and performs optional transformations on subword groups. */
     WordDelimiter = "word_delimiter"
@@ -3931,6 +3954,34 @@ export declare enum KnownTokenizerNames {
     Whitespace = "whitespace"
 }
 
+/** Known values of {@link VectorQueryKind} that the service accepts. */
+export declare enum KnownVectorQueryKind {
+    /** Vector query where a raw vector value is provided. */
+    Vector = "vector",
+    /** Vector query where a text value that needs to be vectorized is provided. */
+    $DO_NOT_NORMALIZE$_text = "text"
+}
+
+/** Known values of {@link VectorSearchCompressionKind} that the service accepts. */
+export declare enum KnownVectorSearchCompressionKind {
+    /** Scalar Quantization, a type of compression method. In scalar quantization, the original vectors values are compressed to a narrower type by discretizing and representing each component of a vector using a reduced set of quantized values, thereby reducing the overall data size. */
+    ScalarQuantization = "scalarQuantization"
+}
+
+/** Known values of {@link VectorSearchCompressionTargetDataType} that the service accepts. */
+export declare enum KnownVectorSearchCompressionTargetDataType {
+    /** Int8 */
+    Int8 = "int8"
+}
+
+/** Known values of {@link VectorSearchVectorizerKind} that the service accepts. */
+export declare enum KnownVectorSearchVectorizerKind {
+    /** Generate embeddings using an Azure OpenAI resource at query time. */
+    AzureOpenAI = "azureOpenAI",
+    /** Generate embeddings using a custom web endpoint at query time. */
+    CustomWebApi = "customWebApi"
+}
+
 /** Known values of {@link VisualFeature} that the service accepts. */
 export declare enum KnownVisualFeature {
     /** Visual features recognized as adult persons. */
@@ -3950,24 +4001,24 @@ export declare enum KnownVisualFeature {
 }
 
 /** A skill that detects the language of input text and reports a single language code for every document submitted on the request. The language code is paired with a score indicating the confidence of the analysis. */
-export declare type LanguageDetectionSkill = BaseSearchIndexerSkill & {
+export declare interface LanguageDetectionSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.LanguageDetectionSkill";
     /** A country code to use as a hint to the language detection model if it cannot disambiguate the language. */
     defaultCountryHint?: string;
     /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
-};
+}
 
 /** Removes words that are too long or too short. This token filter is implemented using Apache Lucene. */
-export declare type LengthTokenFilter = BaseTokenFilter & {
+export declare interface LengthTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.LengthTokenFilter";
     /** The minimum length in characters. Default is 0. Maximum is 300. Must be less than the value of max. */
     minLength?: number;
     /** The maximum length in characters. Default and maximum is 300. */
     maxLength?: number;
-};
+}
 
 /**
  * Contains the possible cases for Analyzer.
@@ -4098,15 +4149,36 @@ export declare type LexicalNormalizerName = string;
  */
 export declare type LexicalTokenizer = ClassicTokenizer | EdgeNGramTokenizer | KeywordTokenizer | MicrosoftLanguageTokenizer | MicrosoftLanguageStemmingTokenizer | NGramTokenizer | PathHierarchyTokenizer | PatternTokenizer | LuceneStandardTokenizer | UaxUrlEmailTokenizer;
 
+/**
+ * Defines values for LexicalTokenizerName. \
+ * {@link KnownLexicalTokenizerName} can be used interchangeably with LexicalTokenizerName,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **classic**: Grammar-based tokenizer that is suitable for processing most European-language documents. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/ClassicTokenizer.html \
+ * **edgeNGram**: Tokenizes the input from an edge into n-grams of the given size(s). See https:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/EdgeNGramTokenizer.html \
+ * **keyword_v2**: Emits the entire input as a single token. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/KeywordTokenizer.html \
+ * **letter**: Divides text at non-letters. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LetterTokenizer.html \
+ * **lowercase**: Divides text at non-letters and converts them to lower case. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LowerCaseTokenizer.html \
+ * **microsoft_language_tokenizer**: Divides text using language-specific rules. \
+ * **microsoft_language_stemming_tokenizer**: Divides text using language-specific rules and reduces words to their base forms. \
+ * **nGram**: Tokenizes the input into n-grams of the given size(s). See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/ngram\/NGramTokenizer.html \
+ * **path_hierarchy_v2**: Tokenizer for path-like hierarchies. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/path\/PathHierarchyTokenizer.html \
+ * **pattern**: Tokenizer that uses regex pattern matching to construct distinct tokens. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/pattern\/PatternTokenizer.html \
+ * **standard_v2**: Standard Lucene analyzer; Composed of the standard tokenizer, lowercase filter and stop filter. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/StandardTokenizer.html \
+ * **uax_url_email**: Tokenizes urls and emails as one token. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/standard\/UAX29URLEmailTokenizer.html \
+ * **whitespace**: Divides text at whitespace. See http:\/\/lucene.apache.org\/core\/4_10_3\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/WhitespaceTokenizer.html
+ */
+export declare type LexicalTokenizerName = string;
+
 /** Limits the number of tokens while indexing. This token filter is implemented using Apache Lucene. */
-export declare type LimitTokenFilter = BaseTokenFilter & {
+export declare interface LimitTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.LimitTokenFilter";
     /** The maximum number of tokens to produce. Default is 1. */
     maxTokenCount?: number;
     /** A value indicating whether all tokens from the input must be consumed even if maxTokenCount is reached. Default is false. */
     consumeAllTokens?: boolean;
-};
+}
 
 /**
  * Defines values for LineEnding. \
@@ -4162,14 +4234,14 @@ export declare type ListSkillsetsOptions = OperationOptions;
 export declare type ListSynonymMapsOptions = OperationOptions;
 
 /** Standard Apache Lucene analyzer; Composed of the standard tokenizer, lowercase filter and stop filter. */
-export declare type LuceneStandardAnalyzer = BaseLexicalAnalyzer & {
+export declare interface LuceneStandardAnalyzer extends BaseLexicalAnalyzer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.StandardAnalyzer";
     /** The maximum token length. Default is 255. Tokens longer than the maximum length are split. The maximum token length that can be used is 300 characters. */
     maxTokenLength?: number;
     /** A list of stopwords. */
     stopwords?: string[];
-};
+}
 
 /**
  * Breaks text following the Unicode Text Segmentation rules. This tokenizer is implemented using
@@ -4194,12 +4266,12 @@ export declare interface LuceneStandardTokenizer {
 }
 
 /** Defines a function that boosts scores based on the magnitude of a numeric field. */
-export declare type MagnitudeScoringFunction = BaseScoringFunction & {
+export declare interface MagnitudeScoringFunction extends BaseScoringFunction {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     type: "magnitude";
     /** Parameter values for the magnitude scoring function. */
     parameters: MagnitudeScoringParameters;
-};
+}
 
 /** Provides parameter values to a magnitude scoring function. */
 export declare interface MagnitudeScoringParameters {
@@ -4212,12 +4284,12 @@ export declare interface MagnitudeScoringParameters {
 }
 
 /** A character filter that applies mappings defined with the mappings option. Matching is greedy (longest pattern matching at a given point wins). Replacement is allowed to be the empty string. This character filter is implemented using Apache Lucene. */
-export declare type MappingCharFilter = BaseCharFilter & {
+export declare interface MappingCharFilter extends BaseCharFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.MappingCharFilter";
     /** A list of mappings of the following format: "a=>b" (all occurrences of the character "a" will be replaced with character "b"). */
     mappings: string[];
-};
+}
 
 /**
  * Options for the merge documents operation.
@@ -4230,17 +4302,17 @@ export declare type MergeDocumentsOptions = IndexDocumentsOptions;
 export declare type MergeOrUploadDocumentsOptions = IndexDocumentsOptions;
 
 /** A skill for merging two or more strings into a single unified string, with an optional user-defined delimiter separating each component part. */
-export declare type MergeSkill = BaseSearchIndexerSkill & {
+export declare interface MergeSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.MergeSkill";
     /** The tag indicates the start of the merged text. By default, the tag is an empty space. */
     insertPreTag?: string;
     /** The tag indicates the end of the merged text. By default, the tag is an empty space. */
     insertPostTag?: string;
-};
+}
 
 /** Divides text using language-specific rules and reduces words to their base forms. */
-export declare type MicrosoftLanguageStemmingTokenizer = BaseLexicalTokenizer & {
+export declare interface MicrosoftLanguageStemmingTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.MicrosoftLanguageStemmingTokenizer";
     /** The maximum token length. Tokens longer than the maximum length are split. Maximum token length that can be used is 300 characters. Tokens longer than 300 characters are first split into tokens of length 300 and then each of those tokens is split based on the max token length set. Default is 255. */
@@ -4249,10 +4321,10 @@ export declare type MicrosoftLanguageStemmingTokenizer = BaseLexicalTokenizer &
     isSearchTokenizer?: boolean;
     /** The language to use. The default is English. */
     language?: MicrosoftStemmingTokenizerLanguage;
-};
+}
 
 /** Divides text using language-specific rules. */
-export declare type MicrosoftLanguageTokenizer = BaseLexicalTokenizer & {
+export declare interface MicrosoftLanguageTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.MicrosoftLanguageTokenizer";
     /** The maximum token length. Tokens longer than the maximum length are split. Maximum token length that can be used is 300 characters. Tokens longer than 300 characters are first split into tokens of length 300 and then each of those tokens is split based on the max token length set. Default is 255. */
@@ -4261,7 +4333,7 @@ export declare type MicrosoftLanguageTokenizer = BaseLexicalTokenizer & {
     isSearchTokenizer?: boolean;
     /** The language to use. The default is English. */
     language?: MicrosoftTokenizerLanguage;
-};
+}
 
 /** Defines values for MicrosoftStemmingTokenizerLanguage. */
 export declare type MicrosoftStemmingTokenizerLanguage = "arabic" | "bangla" | "bulgarian" | "catalan" | "croatian" | "czech" | "danish" | "dutch" | "english" | "estonian" | "finnish" | "french" | "german" | "greek" | "gujarati" | "hebrew" | "hindi" | "hungarian" | "icelandic" | "indonesian" | "italian" | "kannada" | "latvian" | "lithuanian" | "malay" | "malayalam" | "marathi" | "norwegianBokmaal" | "polish" | "portuguese" | "portugueseBrazilian" | "punjabi" | "romanian" | "russian" | "serbianCyrillic" | "serbianLatin" | "slovak" | "slovenian" | "spanish" | "swedish" | "tamil" | "telugu" | "turkish" | "ukrainian" | "urdu";
@@ -4275,10 +4347,10 @@ export declare type MicrosoftTokenizerLanguage = "bangla" | "bulgarian" | "catal
 export declare type NarrowedModel<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> = (<T>() => T extends TModel ? true : false) extends <T>() => T extends never ? true : false ? TModel : (<T>() => T extends TModel ? true : false) extends <T>() => T extends object ? true : false ? TModel : (<T>() => T extends TModel ? true : false) extends <T>() => T extends any ? true : false ? TModel : (<T>() => T extends TModel ? true : false) extends <T>() => T extends unknown ? true : false ? TModel : (<T>() => T extends TFields ? true : false) extends <T>() => T extends never ? true : false ? never : (<T>() => T extends TFields ? true : false) extends <T>() => T extends SelectFields<TModel> ? true : false ? TModel : SearchPick<TModel, TFields>;
 
 /** Defines a data deletion detection policy utilizing Azure Blob Storage's native soft delete feature for deletion detection. */
-export declare type NativeBlobSoftDeleteDeletionDetectionPolicy = BaseDataDeletionDetectionPolicy & {
+export declare interface NativeBlobSoftDeleteDeletionDetectionPolicy extends BaseDataDeletionDetectionPolicy {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.NativeBlobSoftDeleteDeletionDetectionPolicy";
-};
+}
 
 /**
  * Generates n-grams of the given size(s). This token filter is implemented using Apache Lucene.
@@ -4306,7 +4378,7 @@ export declare interface NGramTokenFilter {
 }
 
 /** Tokenizes the input into n-grams of the given size(s). This tokenizer is implemented using Apache Lucene. */
-export declare type NGramTokenizer = BaseLexicalTokenizer & {
+export declare interface NGramTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.NGramTokenizer";
     /** The minimum n-gram length. Default is 1. Maximum is 300. Must be less than the value of maxGram. */
@@ -4315,197 +4387,19 @@ export declare type NGramTokenizer = BaseLexicalTokenizer & {
     maxGram?: number;
     /** Character classes to keep in the tokens. */
     tokenChars?: TokenCharacterKind[];
-};
+}
 
 /** A skill that extracts text from image files. */
-export declare type OcrSkill = BaseSearchIndexerSkill & {
+export declare interface OcrSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Vision.OcrSkill";
     /** A value indicating which language code to use. Default is en. */
     defaultLanguageCode?: OcrSkillLanguage;
     /** A value indicating to turn orientation detection on or not. Default is false. */
     shouldDetectOrientation?: boolean;
-    /** Defines the sequence of characters to use between the lines of text recognized by the OCR skill. The default value is "space". */
-    lineEnding?: LineEnding;
-};
+}
 
-/**
- * Defines values for OcrSkillLanguage. \
- * {@link KnownOcrSkillLanguage} can be used interchangeably with OcrSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **af**: Afrikaans \
- * **sq**: Albanian \
- * **anp**: Angika (Devanagiri) \
- * **ar**: Arabic \
- * **ast**: Asturian \
- * **awa**: Awadhi-Hindi (Devanagiri) \
- * **az**: Azerbaijani (Latin) \
- * **bfy**: Bagheli \
- * **eu**: Basque \
- * **be**: Belarusian (Cyrillic and Latin) \
- * **be-cyrl**: Belarusian (Cyrillic) \
- * **be-latn**: Belarusian (Latin) \
- * **bho**: Bhojpuri-Hindi (Devanagiri) \
- * **bi**: Bislama \
- * **brx**: Bodo (Devanagiri) \
- * **bs**: Bosnian Latin \
- * **bra**: Brajbha \
- * **br**: Breton \
- * **bg**: Bulgarian \
- * **bns**: Bundeli \
- * **bua**: Buryat (Cyrillic) \
- * **ca**: Catalan \
- * **ceb**: Cebuano \
- * **rab**: Chamling \
- * **ch**: Chamorro \
- * **hne**: Chhattisgarhi (Devanagiri) \
- * **zh-Hans**: Chinese Simplified \
- * **zh-Hant**: Chinese Traditional \
- * **kw**: Cornish \
- * **co**: Corsican \
- * **crh**: Crimean Tatar (Latin) \
- * **hr**: Croatian \
- * **cs**: Czech \
- * **da**: Danish \
- * **prs**: Dari \
- * **dhi**: Dhimal (Devanagiri) \
- * **doi**: Dogri (Devanagiri) \
- * **nl**: Dutch \
- * **en**: English \
- * **myv**: Erzya (Cyrillic) \
- * **et**: Estonian \
- * **fo**: Faroese \
- * **fj**: Fijian \
- * **fil**: Filipino \
- * **fi**: Finnish \
- * **fr**: French \
- * **fur**: Frulian \
- * **gag**: Gagauz (Latin) \
- * **gl**: Galician \
- * **de**: German \
- * **gil**: Gilbertese \
- * **gon**: Gondi (Devanagiri) \
- * **el**: Greek \
- * **kl**: Greenlandic \
- * **gvr**: Gurung (Devanagiri) \
- * **ht**: Haitian Creole \
- * **hlb**: Halbi (Devanagiri) \
- * **hni**: Hani \
- * **bgc**: Haryanvi \
- * **haw**: Hawaiian \
- * **hi**: Hindi \
- * **mww**: Hmong Daw (Latin) \
- * **hoc**: Ho (Devanagiri) \
- * **hu**: Hungarian \
- * **is**: Icelandic \
- * **smn**: Inari Sami \
- * **id**: Indonesian \
- * **ia**: Interlingua \
- * **iu**: Inuktitut (Latin) \
- * **ga**: Irish \
- * **it**: Italian \
- * **ja**: Japanese \
- * **Jns**: Jaunsari (Devanagiri) \
- * **jv**: Javanese \
- * **kea**: Kabuverdianu \
- * **kac**: Kachin (Latin) \
- * **xnr**: Kangri (Devanagiri) \
- * **krc**: Karachay-Balkar \
- * **kaa-cyrl**: Kara-Kalpak (Cyrillic) \
- * **kaa**: Kara-Kalpak (Latin) \
- * **csb**: Kashubian \
- * **kk-cyrl**: Kazakh (Cyrillic) \
- * **kk-latn**: Kazakh (Latin) \
- * **klr**: Khaling \
- * **kha**: Khasi \
- * **quc**: K'iche' \
- * **ko**: Korean \
- * **kfq**: Korku \
- * **kpy**: Koryak \
- * **kos**: Kosraean \
- * **kum**: Kumyk (Cyrillic) \
- * **ku-arab**: Kurdish (Arabic) \
- * **ku-latn**: Kurdish (Latin) \
- * **kru**: Kurukh (Devanagiri) \
- * **ky**: Kyrgyz (Cyrillic) \
- * **lkt**: Lakota \
- * **la**: Latin \
- * **lt**: Lithuanian \
- * **dsb**: Lower Sorbian \
- * **smj**: Lule Sami \
- * **lb**: Luxembourgish \
- * **bfz**: Mahasu Pahari (Devanagiri) \
- * **ms**: Malay (Latin) \
- * **mt**: Maltese \
- * **kmj**: Malto (Devanagiri) \
- * **gv**: Manx \
- * **mi**: Maori \
- * **mr**: Marathi \
- * **mn**: Mongolian (Cyrillic) \
- * **cnr-cyrl**: Montenegrin (Cyrillic) \
- * **cnr-latn**: Montenegrin (Latin) \
- * **nap**: Neapolitan \
- * **ne**: Nepali \
- * **niu**: Niuean \
- * **nog**: Nogay \
- * **sme**: Northern Sami (Latin) \
- * **nb**: Norwegian \
- * **no**: Norwegian \
- * **oc**: Occitan \
- * **os**: Ossetic \
- * **ps**: Pashto \
- * **fa**: Persian \
- * **pl**: Polish \
- * **pt**: Portuguese \
- * **pa**: Punjabi (Arabic) \
- * **ksh**: Ripuarian \
- * **ro**: Romanian \
- * **rm**: Romansh \
- * **ru**: Russian \
- * **sck**: Sadri (Devanagiri) \
- * **sm**: Samoan (Latin) \
- * **sa**: Sanskrit (Devanagiri) \
- * **sat**: Santali (Devanagiri) \
- * **sco**: Scots \
- * **gd**: Scottish Gaelic \
- * **sr**: Serbian (Latin) \
- * **sr-Cyrl**: Serbian (Cyrillic) \
- * **sr-Latn**: Serbian (Latin) \
- * **xsr**: Sherpa (Devanagiri) \
- * **srx**: Sirmauri (Devanagiri) \
- * **sms**: Skolt Sami \
- * **sk**: Slovak \
- * **sl**: Slovenian \
- * **so**: Somali (Arabic) \
- * **sma**: Southern Sami \
- * **es**: Spanish \
- * **sw**: Swahili (Latin) \
- * **sv**: Swedish \
- * **tg**: Tajik (Cyrillic) \
- * **tt**: Tatar (Latin) \
- * **tet**: Tetum \
- * **thf**: Thangmi \
- * **to**: Tongan \
- * **tr**: Turkish \
- * **tk**: Turkmen (Latin) \
- * **tyv**: Tuvan \
- * **hsb**: Upper Sorbian \
- * **ur**: Urdu \
- * **ug**: Uyghur (Arabic) \
- * **uz-arab**: Uzbek (Arabic) \
- * **uz-cyrl**: Uzbek (Cyrillic) \
- * **uz**: Uzbek (Latin) \
- * **vo**: Volapük \
- * **wae**: Walser \
- * **cy**: Welsh \
- * **fy**: Western Frisian \
- * **yua**: Yucatec Maya \
- * **za**: Zhuang \
- * **zu**: Zulu \
- * **unk**: Unknown (All)
- */
-export declare type OcrSkillLanguage = string;
+export declare type OcrSkillLanguage = "af" | "sq" | "anp" | "ar" | "ast" | "awa" | "az" | "bfy" | "eu" | "be" | "be-cyrl" | "be-latn" | "bho" | "bi" | "brx" | "bs" | "bra" | "br" | "bg" | "bns" | "bua" | "ca" | "ceb" | "rab" | "ch" | "hne" | "zh-Hans" | "zh-Hant" | "kw" | "co" | "crh" | "hr" | "cs" | "da" | "prs" | "dhi" | "doi" | "nl" | "en" | "myv" | "et" | "fo" | "fj" | "fil" | "fi" | "fr" | "fur" | "gag" | "gl" | "de" | "gil" | "gon" | "el" | "kl" | "gvr" | "ht" | "hlb" | "hni" | "bgc" | "haw" | "hi" | "mww" | "hoc" | "hu" | "is" | "smn" | "id" | "ia" | "iu" | "ga" | "it" | "ja" | "Jns" | "jv" | "kea" | "kac" | "xnr" | "krc" | "kaa-cyrl" | "kaa" | "csb" | "kk-cyrl" | "kk-latn" | "klr" | "kha" | "quc" | "ko" | "kfq" | "kpy" | "kos" | "kum" | "ku-arab" | "ku-latn" | "kru" | "ky" | "lkt" | "la" | "lt" | "dsb" | "smj" | "lb" | "bfz" | "ms" | "mt" | "kmj" | "gv" | "mi" | "mr" | "mn" | "cnr-cyrl" | "cnr-latn" | "nap" | "ne" | "niu" | "nog" | "sme" | "nb" | "no" | "oc" | "os" | "ps" | "fa" | "pl" | "pt" | "pa" | "ksh" | "ro" | "rm" | "ru" | "sck" | "sm" | "sa" | "sat" | "sco" | "gd" | "sr" | "sr-Cyrl" | "sr-Latn" | "xsr" | "srx" | "sms" | "sk" | "sl" | "so" | "sma" | "es" | "sw" | "sv" | "tg" | "tt" | "tet" | "thf" | "to" | "tr" | "tk" | "tyv" | "hsb" | "ur" | "ug" | "uz-arab" | "uz-cyrl" | "uz" | "vo" | "wae" | "cy" | "fy" | "yua" | "za" | "zu" | "unk";
 
 /**
  * Escapes an odata filter expression to avoid errors with quoting string literals.
@@ -4530,7 +4424,7 @@ export declare interface OutputFieldMappingEntry {
 }
 
 /** Tokenizer for path-like hierarchies. This tokenizer is implemented using Apache Lucene. */
-export declare type PathHierarchyTokenizer = BaseLexicalTokenizer & {
+export declare interface PathHierarchyTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.PathHierarchyTokenizerV2";
     /** The delimiter character to use. Default is "/". */
@@ -4543,7 +4437,7 @@ export declare type PathHierarchyTokenizer = BaseLexicalTokenizer & {
     reverseTokenOrder?: boolean;
     /** The number of initial tokens to skip. Default is 0. */
     numberOfTokensToSkip?: number;
-};
+}
 
 /**
  * Flexibly separates text into terms via a regular expression pattern. This analyzer is
@@ -4580,34 +4474,34 @@ export declare interface PatternAnalyzer {
 }
 
 /** Uses Java regexes to emit multiple tokens - one for each capture group in one or more patterns. This token filter is implemented using Apache Lucene. */
-export declare type PatternCaptureTokenFilter = BaseTokenFilter & {
+export declare interface PatternCaptureTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.PatternCaptureTokenFilter";
     /** A list of patterns to match against each token. */
     patterns: string[];
     /** A value indicating whether to return the original token even if one of the patterns matches. Default is true. */
     preserveOriginal?: boolean;
-};
+}
 
 /** A character filter that replaces characters in the input string. It uses a regular expression to identify character sequences to preserve and a replacement pattern to identify characters to replace. For example, given the input text "aa bb aa bb", pattern "(aa)\s+(bb)", and replacement "$1#$2", the result would be "aa#bb aa#bb". This character filter is implemented using Apache Lucene. */
-export declare type PatternReplaceCharFilter = BaseCharFilter & {
+export declare interface PatternReplaceCharFilter extends BaseCharFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.PatternReplaceCharFilter";
     /** A regular expression pattern. */
     pattern: string;
     /** The replacement text. */
     replacement: string;
-};
+}
 
 /** A character filter that replaces characters in the input string. It uses a regular expression to identify character sequences to preserve and a replacement pattern to identify characters to replace. For example, given the input text "aa bb aa bb", pattern "(aa)\s+(bb)", and replacement "$1#$2", the result would be "aa#bb aa#bb". This token filter is implemented using Apache Lucene. */
-export declare type PatternReplaceTokenFilter = BaseTokenFilter & {
+export declare interface PatternReplaceTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.PatternReplaceTokenFilter";
     /** A regular expression pattern. */
     pattern: string;
     /** The replacement text. */
     replacement: string;
-};
+}
 
 /**
  * Tokenizer that uses regex pattern matching to construct distinct tokens. This tokenizer is
@@ -4646,17 +4540,17 @@ export declare interface PatternTokenizer {
 export declare type PhoneticEncoder = "metaphone" | "doubleMetaphone" | "soundex" | "refinedSoundex" | "caverphone1" | "caverphone2" | "cologne" | "nysiis" | "koelnerPhonetik" | "haasePhonetik" | "beiderMorse";
 
 /** Create tokens for phonetic matches. This token filter is implemented using Apache Lucene. */
-export declare type PhoneticTokenFilter = BaseTokenFilter & {
+export declare interface PhoneticTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.PhoneticTokenFilter";
     /** The phonetic encoder to use. Default is "metaphone". */
     encoder?: PhoneticEncoder;
     /** A value indicating whether encoded tokens should replace original tokens. If false, encoded tokens are added as synonyms. Default is true. */
     replaceOriginalTokens?: boolean;
-};
+}
 
 /** Using the Text Analytics API, extracts personal information from an input text and gives you the option of masking it. */
-export declare type PIIDetectionSkill = BaseSearchIndexerSkill & {
+export declare interface PIIDetectionSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.PIIDetectionSkill";
     /** A value indicating which language code to use. Default is en. */
@@ -4670,57 +4564,79 @@ export declare type PIIDetectionSkill = BaseSearchIndexerSkill & {
     /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
     /** A list of PII entity categories that should be extracted and masked. */
-    piiCategories?: string[];
+    categories?: string[];
     /** If specified, will set the PII domain to include only a subset of the entity categories. Possible values include: 'phi', 'none'. Default is 'none'. */
     domain?: string;
-};
-
-/**
- * Defines values for PIIDetectionSkillMaskingMode. \
- * {@link KnownPIIDetectionSkillMaskingMode} can be used interchangeably with PIIDetectionSkillMaskingMode,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: No masking occurs and the maskedText output will not be returned. \
- * **replace**: Replaces the detected entities with the character given in the maskingCharacter parameter. The character will be repeated to the length of the detected entity so that the offsets will correctly correspond to both the input text as well as the output maskedText.
- */
-export declare type PIIDetectionSkillMaskingMode = string;
-
-/** Describes the title, content, and keywords fields to be used for semantic ranking, captions, highlights, and answers. */
-export declare interface PrioritizedFields {
-    /** Defines the title field to be used for semantic ranking, captions, highlights, and answers. If you don't have a title field in your index, leave this blank. */
-    titleField?: SemanticField;
-    /** Defines the content fields to be used for semantic ranking, captions, highlights, and answers. For the best result, the selected fields should contain text in natural language form. The order of the fields in the array represents their priority. Fields with lower priority may get truncated if the content is long. */
-    prioritizedContentFields?: SemanticField[];
-    /** Defines the keyword fields to be used for semantic ranking, captions, highlights, and answers. For the best result, the selected fields should contain a list of keywords. The order of the fields in the array represents their priority. Fields with lower priority may get truncated if the content is long. */
-    prioritizedKeywordsFields?: SemanticField[];
 }
 
-/**
- * Defines values for QueryAnswerType. \
- * {@link KnownQueryAnswerType} can be used interchangeably with QueryAnswerType,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: Do not return answers for the query. \
- * **extractive**: Extracts answer candidates from the contents of the documents returned in response to a query expressed as a question in natural language.
- */
-export declare type QueryAnswerType = string;
+export declare type PIIDetectionSkillMaskingMode = "none" | "replace";
 
 /**
- * Defines values for QueryCaptionType. \
- * {@link KnownQueryCaptionType} can be used interchangeably with QueryCaptionType,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **none**: Do not return captions for the query. \
- * **extractive**: Extracts captions from the matching documents that contain passages relevant to the search query.
+ * A value that specifies whether answers should be returned as part of the search response.
+ * This parameter is only valid if the query type is 'semantic'. If set to `extractive`, the query
+ * returns answers extracted from key passages in the highest ranked documents.
  */
-export declare type QueryCaptionType = string;
+export declare type QueryAnswer = ExtractiveQueryAnswer;
+
+/** An answer is a text passage extracted from the contents of the most relevant documents that matched the query. Answers are extracted from the top search results. Answer candidates are scored and the top answers are selected. */
+export declare interface QueryAnswerResult {
+    /** Describes unknown properties. The value of an unknown property can be of "any" type. */
+    [property: string]: any;
+    /**
+     * The score value represents how relevant the answer is to the query relative to other answers returned for the query.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly score: number;
+    /**
+     * The key of the document the answer was extracted from.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly key: string;
+    /**
+     * The text passage extracted from the document contents as the answer.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly text: string;
+    /**
+     * Same text passage as in the Text property with highlighted text phrases most relevant to the query.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly highlights?: string;
+}
 
 /**
- * disabled: No query debugging information will be returned.
- *
- * semantic: Allows the user to further explore their Semantic search results.
+ * A value that specifies whether captions should be returned as part of the search response.
+ * This parameter is only valid if the query type is 'semantic'. If set, the query returns captions
+ * extracted from key passages in the highest ranked documents. When Captions is 'extractive',
+ * highlighting is enabled by default. Defaults to 'none'.
+ */
+export declare type QueryCaption = ExtractiveQueryCaption;
+
+/** Captions are the most representative passages from the document relatively to the search query. They are often used as document summary. Captions are only returned for queries of type 'semantic'.. */
+export declare interface QueryCaptionResult {
+    /** Describes unknown properties. The value of an unknown property can be of "any" type. */
+    [property: string]: any;
+    /**
+     * A representative text passage extracted from the document most relevant to the search query.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly text?: string;
+    /**
+     * Same text passage as in the Text property with highlighted phrases most relevant to the query.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
+     */
+    readonly highlights?: string;
+}
+
+/**
+ * Defines values for QueryDebugMode. \
+ * {@link KnownQueryDebugMode} can be used interchangeably with QueryDebugMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **disabled**: No query debugging information will be returned. \
+ * **semantic**: Allows the user to further explore their reranked results.
  */
-export declare type QueryDebugMode = "disabled" | "semantic";
+export declare type QueryDebugMode = string;
 
 /**
  * Defines values for QueryLanguage. \
@@ -4778,7 +4694,7 @@ export declare type QueryDebugMode = "disabled" | "semantic";
  * **uk-ua**: Query language value for Ukrainian (Ukraine). \
  * **lv-lv**: Query language value for Latvian (Latvia). \
  * **et-ee**: Query language value for Estonian (Estonia). \
- * **ca-es**: Query language value for Catalan (Spain). \
+ * **ca-es**: Query language value for Catalan. \
  * **fi-fi**: Query language value for Finnish (Finland). \
  * **sr-ba**: Query language value for Serbian (Bosnia and Herzegovina). \
  * **sr-me**: Query language value for Serbian (Montenegro). \
@@ -4787,8 +4703,8 @@ export declare type QueryDebugMode = "disabled" | "semantic";
  * **nb-no**: Query language value for Norwegian (Norway). \
  * **hy-am**: Query language value for Armenian (Armenia). \
  * **bn-in**: Query language value for Bengali (India). \
- * **eu-es**: Query language value for Basque (Spain). \
- * **gl-es**: Query language value for Galician (Spain). \
+ * **eu-es**: Query language value for Basque. \
+ * **gl-es**: Query language value for Galician. \
  * **gu-in**: Query language value for Gujarati (India). \
  * **he-il**: Query language value for Hebrew (Israel). \
  * **ga-ie**: Query language value for Irish (Ireland). \
@@ -4848,29 +4764,7 @@ export declare type QuerySpellerType = string;
 /** Defines values for QueryType. */
 export declare type QueryType = "simple" | "full" | "semantic";
 
-/** The query parameters to use for vector search when a raw vector value is provided. */
-export declare interface RawVectorQuery<TModel extends object> extends BaseVectorQuery<TModel> {
-    /** Polymorphic discriminator, which specifies the different types this object can be */
-    kind: "vector";
-    /** The vector representation of a search query. */
-    vector?: number[];
-}
-
-/**
- * Defines values for RegexFlags. \
- * {@link KnownRegexFlags} can be used interchangeably with RegexFlags,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **CANON_EQ**: Enables canonical equivalence. \
- * **CASE_INSENSITIVE**: Enables case-insensitive matching. \
- * **COMMENTS**: Permits whitespace and comments in the pattern. \
- * **DOTALL**: Enables dotall mode. \
- * **LITERAL**: Enables literal parsing of the pattern. \
- * **MULTILINE**: Enables multiline mode. \
- * **UNICODE_CASE**: Enables Unicode-aware case folding. \
- * **UNIX_LINES**: Enables Unix lines mode.
- */
-export declare type RegexFlags = string;
+export declare type RegexFlags = "CANON_EQ" | "CASE_INSENSITIVE" | "COMMENTS" | "DOTALL" | "LITERAL" | "MULTILINE" | "UNICODE_CASE" | "UNIX_LINES";
 
 /**
  * Options for reset docs operation.
@@ -4910,6 +4804,20 @@ export declare interface ResourceCounter {
  */
 export declare type RunIndexerOptions = OperationOptions;
 
+/** Contains configuration options specific to the scalar quantization compression method used during indexing and querying. */
+export declare interface ScalarQuantizationCompressionConfiguration extends BaseVectorSearchCompressionConfiguration {
+    /** Polymorphic discriminator, which specifies the different types this object can be */
+    kind: "scalarQuantization";
+    /** Contains the parameters specific to Scalar Quantization. */
+    parameters?: ScalarQuantizationParameters;
+}
+
+/** Contains the parameters specific to Scalar Quantization. */
+export declare interface ScalarQuantizationParameters {
+    /** The quantized data type of compressed vector values. */
+    quantizedDataType?: VectorSearchCompressionTargetDataType;
+}
+
 /**
  * Contains the possible cases for ScoringFunction.
  */
@@ -4981,7 +4889,15 @@ export declare class SearchClient<TModel extends object> implements IndexDocumen
      * The name of the index
      */
     readonly indexName: string;
-    /* Excluded from this release type: client */
+    /**
+     * @hidden
+     * A reference to the auto-generated SearchClient
+     */
+    private readonly client;
+    /**
+     * A reference to the internal HTTP pipeline for use with raw requests
+     */
+    readonly pipeline: Pipeline;
     /**
      * Creates an instance of SearchClient.
      *
@@ -5190,7 +5106,8 @@ export declare class SearchClient<TModel extends object> implements IndexDocumen
     private convertSearchFields;
     private convertSemanticFields;
     private convertOrderBy;
-    private convertAnswers;
+    private convertQueryAnswers;
+    private convertQueryCaptions;
     private convertVectorQuery;
 }
 
@@ -5273,17 +5190,17 @@ export declare interface SearchDocumentsResultBase {
      * not specified or set to 'none'.
      * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    readonly answers?: AnswerResult[];
+    readonly answers?: QueryAnswerResult[];
     /**
      * Reason that a partial response was returned for a semantic search request.
      * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    readonly semanticPartialResponseReason?: SemanticPartialResponseReason;
+    readonly semanticErrorReason?: SemanticErrorReason;
     /**
      * Type of partial response that was returned for a semantic search request.
      * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    readonly semanticPartialResponseType?: SemanticPartialResponseType;
+    readonly semanticSearchResultsType?: SemanticSearchResultsType;
 }
 
 /**
@@ -5303,12 +5220,13 @@ export declare type SearchFieldArray<TModel extends object = object> = (<T>() =>
  * Possible values include: 'Edm.String', 'Edm.Int32', 'Edm.Int64', 'Edm.Double', 'Edm.Boolean',
  * 'Edm.DateTimeOffset', 'Edm.GeographyPoint', 'Collection(Edm.String)', 'Collection(Edm.Int32)',
  * 'Collection(Edm.Int64)', 'Collection(Edm.Double)', 'Collection(Edm.Boolean)',
- * 'Collection(Edm.DateTimeOffset)', 'Collection(Edm.GeographyPoint)', 'Collection(Edm.Single)'
+ * 'Collection(Edm.DateTimeOffset)', 'Collection(Edm.GeographyPoint)', 'Collection(Edm.Single)',
+ * 'Collection(Edm.Half)', 'Collection(Edm.Int16)', 'Collection(Edm.SByte)'
  *
  * NB: `Edm.Single` alone is not a valid data type. It must be used as part of a collection type.
  * @readonly
  */
-export declare type SearchFieldDataType = "Edm.String" | "Edm.Int32" | "Edm.Int64" | "Edm.Double" | "Edm.Boolean" | "Edm.DateTimeOffset" | "Edm.GeographyPoint" | "Collection(Edm.String)" | "Collection(Edm.Int32)" | "Collection(Edm.Int64)" | "Collection(Edm.Double)" | "Collection(Edm.Boolean)" | "Collection(Edm.DateTimeOffset)" | "Collection(Edm.GeographyPoint)" | "Collection(Edm.Single)";
+export declare type SearchFieldDataType = "Edm.String" | "Edm.Int32" | "Edm.Int64" | "Edm.Double" | "Edm.Boolean" | "Edm.DateTimeOffset" | "Edm.GeographyPoint" | "Collection(Edm.String)" | "Collection(Edm.Int32)" | "Collection(Edm.Int64)" | "Collection(Edm.Double)" | "Collection(Edm.Boolean)" | "Collection(Edm.DateTimeOffset)" | "Collection(Edm.GeographyPoint)" | "Collection(Edm.Single)" | "Collection(Edm.Half)" | "Collection(Edm.Int16)" | "Collection(Edm.SByte)";
 
 /**
  * Represents a search index definition, which describes the fields and search behavior of an
@@ -5381,7 +5299,7 @@ export declare interface SearchIndex {
     /**
      * Defines parameters for a search index that influence semantic capabilities.
      */
-    semanticSettings?: SemanticSettings;
+    semanticSearch?: SemanticSearch;
     /**
      * Contains configuration options related to vector search.
      */
@@ -5416,7 +5334,15 @@ export declare class SearchIndexClient {
      * The endpoint of the search service
      */
     readonly endpoint: string;
-    /* Excluded from this release type: client */
+    /**
+     * @hidden
+     * A reference to the auto-generated SearchServiceClient
+     */
+    private readonly client;
+    /**
+     * A reference to the internal HTTP pipeline for use with raw requests
+     */
+    readonly pipeline: Pipeline;
     /**
      * Used to authenticate requests to the service.
      */
@@ -5703,7 +5629,15 @@ export declare class SearchIndexerClient {
      * The endpoint of the search service
      */
     readonly endpoint: string;
-    /* Excluded from this release type: client */
+    /**
+     * @hidden
+     * A reference to the auto-generated SearchServiceClient
+     */
+    private readonly client;
+    /**
+     * A reference to the internal HTTP pipeline for use with raw requests
+     */
+    readonly pipeline: Pipeline;
     /**
      * Creates an instance of SearchIndexerClient.
      *
@@ -5891,10 +5825,10 @@ export declare interface SearchIndexerDataContainer {
 export declare type SearchIndexerDataIdentity = SearchIndexerDataNoneIdentity | SearchIndexerDataUserAssignedIdentity;
 
 /** Clears the identity property of a datasource. */
-export declare type SearchIndexerDataNoneIdentity = BaseSearchIndexerDataIdentity & {
+export declare interface SearchIndexerDataNoneIdentity extends BaseSearchIndexerDataIdentity {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.DataNoneIdentity";
-};
+}
 
 /**
  * Represents a datasource definition, which can be used to configure an indexer.
@@ -5953,27 +5887,15 @@ export declare interface SearchIndexerDataSourceConnection {
     encryptionKey?: SearchResourceEncryptionKey;
 }
 
-/**
- * Defines values for SearchIndexerDataSourceType. \
- * {@link KnownSearchIndexerDataSourceType} can be used interchangeably with SearchIndexerDataSourceType,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **azuresql**: Indicates an Azure SQL datasource. \
- * **cosmosdb**: Indicates a CosmosDB datasource. \
- * **azureblob**: Indicates an Azure Blob datasource. \
- * **azuretable**: Indicates an Azure Table datasource. \
- * **mysql**: Indicates a MySql datasource. \
- * **adlsgen2**: Indicates an ADLS Gen2 datasource.
- */
-export declare type SearchIndexerDataSourceType = string;
+export declare type SearchIndexerDataSourceType = "azuresql" | "cosmosdb" | "azureblob" | "azuretable" | "mysql" | "adlsgen2";
 
 /** Specifies the identity for a datasource to use. */
-export declare type SearchIndexerDataUserAssignedIdentity = BaseSearchIndexerDataIdentity & {
+export declare interface SearchIndexerDataUserAssignedIdentity extends BaseSearchIndexerDataIdentity {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.DataUserAssignedIdentity";
     /** The fully qualified Azure resource Id of a user assigned managed identity typically in the form "/subscriptions/12345678-1234-1234-1234-1234567890ab/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId" that should have been assigned to the search service. */
     userAssignedIdentity: string;
-};
+}
 
 /** Represents an item- or document-level indexing error. */
 export declare interface SearchIndexerError {
@@ -6060,16 +5982,18 @@ export declare interface SearchIndexerKnowledgeStore {
 }
 
 /** Abstract class to share properties between concrete selectors. */
-export declare type SearchIndexerKnowledgeStoreBlobProjectionSelector = SearchIndexerKnowledgeStoreProjectionSelector & {
+export declare interface SearchIndexerKnowledgeStoreBlobProjectionSelector extends SearchIndexerKnowledgeStoreProjectionSelector {
     /** Blob container to store projections in. */
     storageContainer: string;
-};
+}
 
 /** Projection definition for what data to store in Azure Files. */
-export declare type SearchIndexerKnowledgeStoreFileProjectionSelector = SearchIndexerKnowledgeStoreBlobProjectionSelector & {};
+export declare interface SearchIndexerKnowledgeStoreFileProjectionSelector extends SearchIndexerKnowledgeStoreBlobProjectionSelector {
+}
 
 /** Projection definition for what data to store in Azure Blob. */
-export declare type SearchIndexerKnowledgeStoreObjectProjectionSelector = SearchIndexerKnowledgeStoreBlobProjectionSelector & {};
+export declare interface SearchIndexerKnowledgeStoreObjectProjectionSelector extends SearchIndexerKnowledgeStoreBlobProjectionSelector {
+}
 
 /** A dictionary of knowledge store-specific configuration properties. Each name is the name of a specific property. Each value must be of a primitive type. */
 export declare interface SearchIndexerKnowledgeStoreParameters {
@@ -6104,10 +6028,10 @@ export declare interface SearchIndexerKnowledgeStoreProjectionSelector {
 }
 
 /** Description for what data to store in Azure Tables. */
-export declare type SearchIndexerKnowledgeStoreTableProjectionSelector = SearchIndexerKnowledgeStoreProjectionSelector & {
+export declare interface SearchIndexerKnowledgeStoreTableProjectionSelector extends SearchIndexerKnowledgeStoreProjectionSelector {
     /** Name of the Azure table to store projected data in. */
     tableName: string;
-};
+}
 
 export declare interface SearchIndexerLimits {
     /**
@@ -6130,7 +6054,7 @@ export declare interface SearchIndexerLimits {
 /**
  * Contains the possible cases for Skill.
  */
-export declare type SearchIndexerSkill = ConditionalSkill | KeyPhraseExtractionSkill | OcrSkill | ImageAnalysisSkill | LanguageDetectionSkill | ShaperSkill | MergeSkill | EntityRecognitionSkill | SentimentSkill | SplitSkill | PIIDetectionSkill | EntityRecognitionSkillV3 | EntityLinkingSkill | SentimentSkillV3 | CustomEntityLookupSkill | TextTranslationSkill | DocumentExtractionSkill | WebApiSkill | AzureMachineLearningSkill | AzureOpenAIEmbeddingSkill;
+export declare type SearchIndexerSkill = AzureMachineLearningSkill | AzureOpenAIEmbeddingSkill | ConditionalSkill | CustomEntityLookupSkill | DocumentExtractionSkill | EntityLinkingSkill | EntityRecognitionSkill | EntityRecognitionSkillV3 | ImageAnalysisSkill | KeyPhraseExtractionSkill | LanguageDetectionSkill | MergeSkill | OcrSkill | PIIDetectionSkill | SentimentSkill | SentimentSkillV3 | ShaperSkill | SplitSkill | TextTranslationSkill | WebApiSkill;
 
 /**
  * A list of skills.
@@ -6474,7 +6398,7 @@ export declare interface SearchIndexStatistics {
      * The amount of memory in bytes consumed by vectors in the index.
      * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    readonly vectorIndexSize?: number;
+    readonly vectorIndexSize: number;
 }
 
 /**
@@ -6506,586 +6430,275 @@ UnionToIntersection<TFields extends `${infer FieldName}/${infer RestPaths}` ? Fi
 /**
  * Parameters for filtering, sorting, faceting, paging, and other search query behaviors.
  */
-export declare interface SearchRequest<TModel extends object = never> {
-    /**
-     * A value that specifies whether to fetch the total count of results. Default is false. Setting
-     * this value to true may have a performance impact. Note that the count returned is an
-     * approximation.
-     */
-    includeTotalCount?: boolean;
+export declare type SearchRequestOptions<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> = BaseSearchRequestOptions<TModel, TFields> & SearchRequestQueryTypeOptions;
+
+export declare type SearchRequestQueryTypeOptions = {
+    queryType: "semantic";
     /**
-     * The list of facet expressions to apply to the search query. Each facet expression contains a
-     * field name, optionally followed by a comma-separated list of name:value pairs.
+     * Defines options for semantic search queries
      */
-    facets?: string[];
+    semanticSearchOptions: SemanticSearchOptions;
+} | {
+    queryType?: "simple" | "full";
+};
+
+/**
+ * A customer-managed encryption key in Azure Key Vault. Keys that you create and manage can be
+ * used to encrypt or decrypt data-at-rest in Azure Cognitive Search, such as indexes and synonym
+ * maps.
+ */
+export declare interface SearchResourceEncryptionKey {
     /**
-     * The OData $filter expression to apply to the search query.
+     * The name of your Azure Key Vault key to be used to encrypt your data at rest.
      */
-    filter?: string;
+    keyName: string;
     /**
-     * The comma-separated list of field names to use for hit highlights. Only searchable fields can
-     * be used for hit highlighting.
+     * The version of your Azure Key Vault key to be used to encrypt your data at rest.
      */
-    highlightFields?: string;
+    keyVersion: string;
     /**
-     * A string tag that is appended to hit highlights. Must be set with highlightPreTag. Default is
-     * &lt;/em&gt;.
+     * The URI of your Azure Key Vault, also referred to as DNS name, that contains the key to be
+     * used to encrypt your data at rest. An example URI might be
+     * https://my-keyvault-name.vault.azure.net.
      */
-    highlightPostTag?: string;
+    vaultUrl: string;
     /**
-     * A string tag that is prepended to hit highlights. Must be set with highlightPostTag. Default
-     * is &lt;em&gt;.
+     * An AAD Application ID that was granted the required access permissions to the Azure Key Vault
+     * that is to be used when encrypting your data at rest. The Application ID should not be
+     * confused with the Object ID for your AAD Application.
      */
-    highlightPreTag?: string;
+    applicationId?: string;
     /**
-     * A number between 0 and 100 indicating the percentage of the index that must be covered by a
-     * search query in order for the query to be reported as a success. This parameter can be useful
-     * for ensuring search availability even for services with only one replica. The default is 100.
+     * The authentication key of the specified AAD application.
      */
-    minimumCoverage?: number;
+    applicationSecret?: string;
     /**
-     * The comma-separated list of OData $orderby expressions by which to sort the results. Each
-     * expression can be either a field name or a call to either the geo.distance() or the
-     * search.score() functions. Each expression can be followed by asc to indicate ascending, or
-     * desc to indicate descending. The default is ascending order. Ties will be broken by the match
-     * scores of documents. If no $orderby is specified, the default sort order is descending by
-     * document match score. There can be at most 32 $orderby clauses.
+     * An explicit managed identity to use for this encryption key. If not specified and the access
+     * credentials property is null, the system-assigned managed identity is used. On update to the
+     * resource, if the explicit identity is unspecified, it remains unchanged. If "none" is specified,
+     * the value of this property is cleared.
      */
-    orderBy?: string;
+    identity?: SearchIndexerDataIdentity;
+}
+
+/**
+ * Contains a document found by a search query, plus associated metadata.
+ */
+export declare type SearchResult<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> = {
     /**
-     * A value that specifies the syntax of the search query. The default is 'simple'. Use 'full' if
-     * your query uses the Lucene query syntax. Possible values include: 'Simple', 'Full'
+     * The relevance score of the document compared to other documents returned by the query.
+     * **NOTE: This property will not be serialized. It can only be populated by the server.**
      */
-    queryType?: QueryType;
+    readonly score: number;
     /**
-     * A value that specifies whether we want to calculate scoring statistics (such as document
-     * frequency) globally for more consistent scoring, or locally, for lower latency. The default is
-     * 'local'. Use 'global' to aggregate scoring statistics globally before scoring. Using global
-     * scoring statistics can increase latency of search queries. Possible values include: 'Local',
-     * 'Global'
+     * The relevance score computed by the semantic ranker for the top search results. Search results are sorted by the RerankerScore first and then by the Score. RerankerScore is only returned for queries of type 'semantic'.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    scoringStatistics?: ScoringStatistics;
+    readonly rerankerScore?: number;
     /**
-     * A value to be used to create a sticky session, which can help getting more consistent results.
-     * As long as the same sessionId is used, a best-effort attempt will be made to target the same
-     * replica set. Be wary that reusing the same sessionID values repeatedly can interfere with the
-     * load balancing of the requests across replicas and adversely affect the performance of the
-     * search service. The value used as sessionId cannot start with a '_' character.
+     * Text fragments from the document that indicate the matching search terms, organized by each
+     * applicable field; null if hit highlighting was not enabled for the query.
+     * **NOTE: This property will not be serialized. It can only be populated by the server.**
      */
-    sessionId?: string;
+    readonly highlights?: {
+        [k in SelectFields<TModel>]?: string[];
+    };
     /**
-     * The list of parameter values to be used in scoring functions (for example,
-     * referencePointParameter) using the format name-values. For example, if the scoring profile
-     * defines a function with a parameter called 'mylocation' the parameter string would be
-     * "mylocation--122.2,44.8" (without the quotes).
+     * Captions are the most representative passages from the document relatively to the search query. They are often used as document summary. Captions are only returned for queries of type 'semantic'.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    scoringParameters?: string[];
+    readonly captions?: QueryCaptionResult[];
+    document: NarrowedModel<TModel, TFields>;
     /**
-     * The name of a scoring profile to evaluate match scores for matching documents in order to sort
-     * the results.
+     * Contains debugging information that can be used to further explore your search results.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    scoringProfile?: string;
+    readonly documentDebugInfo?: DocumentDebugInfo[];
+};
+
+/**
+ * Response from a get service statistics request. If successful, it includes service level
+ * counters and limits.
+ */
+export declare interface SearchServiceStatistics {
     /**
-     * Allows setting a separate search query that will be solely used for semantic reranking,
-     * semantic captions and semantic answers. Is useful for scenarios where there is a need to use
-     * different queries between the base retrieval and ranking phase, and the L2 semantic phase.
+     * Service level resource counters.
      */
-    semanticQuery?: string;
+    counters: ServiceCounters;
     /**
-     * The name of a semantic configuration that will be used when processing documents for queries of
-     * type semantic.
+     * Service level general limits.
      */
-    semanticConfiguration?: string;
+    limits: ServiceLimits;
+}
+
+/** Defines how the Suggest API should apply to a group of fields in the index. */
+export declare interface SearchSuggester {
+    /** The name of the suggester. */
+    name: string;
+    /** A value indicating the capabilities of the suggester. */
+    searchMode: "analyzingInfixMatching";
+    /** The list of field names to which the suggester applies. Each field must be searchable. */
+    sourceFields: string[];
+}
+
+/**
+ * If `TFields` is never, an untyped string array
+ * Otherwise, a narrowed `Fields[]` type to be used elsewhere in the consuming type.
+ */
+export declare type SelectArray<TFields = never> = [string] extends [TFields] ? readonly TFields[] : (<T>() => T extends TFields ? true : false) extends <T>() => T extends never ? true : false ? readonly string[] : readonly TFields[];
+
+/**
+ * Produces a union of valid Cognitive Search OData $select paths for T
+ * using a post-order traversal of the field tree rooted at T.
+ */
+export declare type SelectFields<TModel extends object> = (<T>() => T extends TModel ? true : false) extends <T>() => T extends never ? true : false ? string : (<T>() => T extends TModel ? true : false) extends <T>() => T extends any ? true : false ? string : (<T>() => T extends TModel ? true : false) extends <T>() => T extends object ? true : false ? string : TModel extends Array<infer Elem> ? Elem extends object ? SelectFields<Elem> : never : {
+    [Key in keyof TModel]: Key extends string ? NonNullable<TModel[Key]> extends object ? NonNullable<TModel[Key]> extends ExcludedODataTypes ? Key : SelectFields<NonNullable<TModel[Key]>> extends infer NextPaths ? (<T>() => T extends NextPaths ? true : false) extends <T>() => T extends never ? true : false ? Key : NextPaths extends string ? Key | `${Key}/${NextPaths}` : Key : never : Key : never;
+}[keyof TModel & string] & string;
+
+/** Defines a specific configuration to be used in the context of semantic capabilities. */
+export declare interface SemanticConfiguration {
+    /** The name of the semantic configuration. */
+    name: string;
+    /** Describes the title, content, and keyword fields to be used for semantic ranking, captions, highlights, and answers. At least one of the three sub properties (titleField, prioritizedKeywordsFields and prioritizedContentFields) need to be set. */
+    prioritizedFields: SemanticPrioritizedFields;
+}
+
+/**
+ * Debug options for semantic search queries.
+ */
+export declare interface SemanticDebugInfo {
     /**
-     * Allows the user to choose whether a semantic call should fail completely, or to return partial
-     * results (default).
+     * The title field that was sent to the semantic enrichment process, as well as how it was used
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    semanticErrorHandlingMode?: SemanticErrorHandlingMode;
+    readonly titleField?: QueryResultDocumentSemanticField;
     /**
-     * Allows the user to set an upper bound on the amount of time it takes for semantic enrichment
-     * to finish processing before the request fails.
+     * The content fields that were sent to the semantic enrichment process, as well as how they were used
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    semanticMaxWaitInMilliseconds?: number;
+    readonly contentFields?: QueryResultDocumentSemanticField[];
     /**
-     * Enables a debugging tool that can be used to further explore your Semantic search results.
+     * The keyword fields that were sent to the semantic enrichment process, as well as how they were used
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    debugMode?: QueryDebugMode;
+    readonly keywordFields?: QueryResultDocumentSemanticField[];
     /**
-     * A full-text search query expression; Use "*" or omit this parameter to match all documents.
+     * The raw concatenated strings that were sent to the semantic enrichment process.
+     * NOTE: This property will not be serialized. It can only be populated by the server.
      */
-    searchText?: string;
-    /**
-     * The comma-separated list of field names to which to scope the full-text search. When using
-     * fielded search (fieldName:searchExpression) in a full Lucene query, the field names of each
-     * fielded search expression take precedence over any field names listed in this parameter.
-     */
-    searchFields?: string;
-    /**
-     * A value that specifies whether any or all of the search terms must be matched in order to
-     * count the document as a match. Possible values include: 'Any', 'All'
-     */
-    searchMode?: SearchMode;
-    /**
-     * A value that specifies the language of the search query.
-     */
-    queryLanguage?: QueryLanguage;
-    /**
-     * A value that specified the type of the speller to use to spell-correct individual search
-     * query terms.
-     */
-    speller?: QuerySpellerType;
-    /**
-     * A value that specifies whether answers should be returned as part of the search response.
-     */
-    answers?: QueryAnswerType;
-    /**
-     * The comma-separated list of fields to retrieve. If unspecified, all fields marked as
-     * retrievable in the schema are included.
-     */
-    select?: string;
-    /**
-     * The number of search results to skip. This value cannot be greater than 100,000. If you need
-     * to scan documents in sequence, but cannot use skip due to this limitation, consider using
-     * orderby on a totally-ordered key and filter with a range query instead.
-     */
-    skip?: number;
-    /**
-     * The number of search results to retrieve. This can be used in conjunction with $skip to
-     * implement client-side paging of search results. If results are truncated due to server-side
-     * paging, the response will include a continuation token that can be used to issue another
-     * Search request for the next page of results.
-     */
-    top?: number;
-    /**
-     * A value that specifies whether captions should be returned as part of the search response.
-     */
-    captions?: QueryCaptionType;
-    /**
-     * The comma-separated list of field names used for semantic search.
-     */
-    semanticFields?: string;
-    /**
-     * The query parameters for vector, hybrid, and multi-vector search queries.
-     */
-    vectorQueries?: VectorQuery<TModel>[];
-    /**
-     * Determines whether or not filters are applied before or after the vector search is performed.
-     * Default is 'preFilter'.
-     */
-    vectorFilterMode?: VectorFilterMode;
+    readonly rerankerInput?: QueryResultDocumentRerankerInput;
 }
 
-/**
- * Parameters for filtering, sorting, faceting, paging, and other search query behaviors.
- */
-export declare interface SearchRequestOptions<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> {
-    /**
-     * A value that specifies whether to fetch the total count of results. Default is false. Setting
-     * this value to true may have a performance impact. Note that the count returned is an
-     * approximation.
-     */
-    includeTotalCount?: boolean;
-    /**
-     * The list of facet expressions to apply to the search query. Each facet expression contains a
-     * field name, optionally followed by a comma-separated list of name:value pairs.
-     */
-    facets?: string[];
-    /**
-     * The OData $filter expression to apply to the search query.
-     */
-    filter?: string;
-    /**
-     * The comma-separated list of field names to use for hit highlights. Only searchable fields can
-     * be used for hit highlighting.
-     */
-    highlightFields?: string;
-    /**
-     * A string tag that is appended to hit highlights. Must be set with highlightPreTag. Default is
-     * &lt;/em&gt;.
-     */
-    highlightPostTag?: string;
-    /**
-     * A string tag that is prepended to hit highlights. Must be set with highlightPostTag. Default
-     * is &lt;em&gt;.
-     */
-    highlightPreTag?: string;
-    /**
-     * A number between 0 and 100 indicating the percentage of the index that must be covered by a
-     * search query in order for the query to be reported as a success. This parameter can be useful
-     * for ensuring search availability even for services with only one replica. The default is 100.
-     */
-    minimumCoverage?: number;
-    /**
-     * The list of OData $orderby expressions by which to sort the results. Each
-     * expression can be either a field name or a call to either the geo.distance() or the
-     * search.score() functions. Each expression can be followed by asc to indicate ascending, or
-     * desc to indicate descending. The default is ascending order. Ties will be broken by the match
-     * scores of documents. If no $orderby is specified, the default sort order is descending by
-     * document match score. There can be at most 32 $orderby clauses.
-     */
-    orderBy?: string[];
-    /**
-     * A value that specifies the syntax of the search query. The default is 'simple'. Use 'full' if
-     * your query uses the Lucene query syntax. Possible values include: 'simple', 'full', 'semantic'
-     */
-    queryType?: QueryType;
-    /**
-     * The list of parameter values to be used in scoring functions (for example,
-     * referencePointParameter) using the format name-values. For example, if the scoring profile
-     * defines a function with a parameter called 'mylocation' the parameter string would be
-     * "mylocation--122.2,44.8" (without the quotes).
-     */
-    scoringParameters?: string[];
-    /**
-     * The name of a scoring profile to evaluate match scores for matching documents in order to sort
-     * the results.
-     */
-    scoringProfile?: string;
-    /**
-     * Allows setting a separate search query that will be solely used for semantic reranking,
-     * semantic captions and semantic answers. Is useful for scenarios where there is a need to use
-     * different queries between the base retrieval and ranking phase, and the L2 semantic phase.
-     */
-    semanticQuery?: string;
-    /**
-     * The name of a semantic configuration that will be used when processing documents for queries of
-     * type semantic.
-     */
-    semanticConfiguration?: string;
-    /**
-     * Allows the user to choose whether a semantic call should fail completely, or to return
-     * partial results (default).
-     */
-    semanticErrorHandlingMode?: SemanticErrorHandlingMode;
-    /**
-     * Allows the user to set an upper bound on the amount of time it takes for semantic enrichment to finish
-     * processing before the request fails.
-     */
-    semanticMaxWaitInMilliseconds?: number;
-    /**
-     * Enables a debugging tool that can be used to further explore your search results.
-     */
-    debugMode?: QueryDebugMode;
-    /**
-     * The comma-separated list of field names to which to scope the full-text search. When using
-     * fielded search (fieldName:searchExpression) in a full Lucene query, the field names of each
-     * fielded search expression take precedence over any field names listed in this parameter.
-     */
-    searchFields?: SearchFieldArray<TModel>;
-    /**
-     * The language of the query.
-     */
-    queryLanguage?: QueryLanguage;
-    /**
-     * Improve search recall by spell-correcting individual search query terms.
-     */
-    speller?: Speller;
-    /**
-     * This parameter is only valid if the query type is 'semantic'. If set, the query returns answers
-     * extracted from key passages in the highest ranked documents.
-     */
-    answers?: Answers | AnswersOptions;
-    /**
-     * A value that specifies whether any or all of the search terms must be matched in order to
-     * count the document as a match. Possible values include: 'any', 'all'
-     */
-    searchMode?: SearchMode;
-    /**
-     * A value that specifies whether we want to calculate scoring statistics (such as document
-     * frequency) globally for more consistent scoring, or locally, for lower latency. Possible
-     * values include: 'Local', 'Global'
-     */
-    scoringStatistics?: ScoringStatistics;
-    /**
-     * A value to be used to create a sticky session, which can help to get more consistent results.
-     * As long as the same sessionId is used, a best-effort attempt will be made to target the same
-     * replica set. Be wary that reusing the same sessionID values repeatedly can interfere with the
-     * load balancing of the requests across replicas and adversely affect the performance of the
-     * search service. The value used as sessionId cannot start with a '_' character.
-     */
-    sessionId?: string;
-    /**
-     * The list of fields to retrieve. If unspecified, all fields marked as
-     * retrievable in the schema are included.
-     */
-    select?: SelectArray<TFields>;
-    /**
-     * The number of search results to skip. This value cannot be greater than 100,000. If you need
-     * to scan documents in sequence, but cannot use skip due to this limitation, consider using
-     * orderby on a totally-ordered key and filter with a range query instead.
-     */
-    skip?: number;
-    /**
-     * The number of search results to retrieve. This can be used in conjunction with $skip to
-     * implement client-side paging of search results. If results are truncated due to server-side
-     * paging, the response will include a continuation token that can be used to issue another
-     * Search request for the next page of results.
-     */
-    top?: number;
-    /**
-     * This parameter is only valid if the query type is 'semantic'. If set, the query returns captions
-     * extracted from key passages in the highest ranked documents. When Captions is set to 'extractive',
-     * highlighting is enabled by default, and can be configured by appending the pipe character '|'
-     * followed by the 'highlight-true'/'highlight-false' option, such as 'extractive|highlight-true'. Defaults to 'None'.
-     */
-    captions?: Captions;
-    /**
-     * The list of field names used for semantic search.
-     */
-    semanticFields?: string[];
-    /**
-     * The query parameters for vector and hybrid search queries.
-     */
-    vectorQueries?: VectorQuery<TModel>[];
-    /**
-     * Determines whether or not filters are applied before or after the vector search is performed.
-     * Default is 'preFilter'.
-     */
-    vectorFilterMode?: VectorFilterMode;
+export declare type SemanticErrorMode = "partial" | "fail";
+
+export declare type SemanticErrorReason = "maxWaitExceeded" | "capacityOverloaded" | "transient";
+
+/** A field that is used as part of the semantic configuration. */
+export declare interface SemanticField {
+    name: string;
 }
 
 /**
- * A customer-managed encryption key in Azure Key Vault. Keys that you create and manage can be
- * used to encrypt or decrypt data-at-rest in Azure Cognitive Search, such as indexes and synonym
- * maps.
+ * Defines values for SemanticFieldState. \
+ * {@link KnownSemanticFieldState} can be used interchangeably with SemanticFieldState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **used**: The field was fully used for semantic enrichment. \
+ * **unused**: The field was not used for semantic enrichment. \
+ * **partial**: The field was partially used for semantic enrichment.
  */
-export declare interface SearchResourceEncryptionKey {
-    /**
-     * The name of your Azure Key Vault key to be used to encrypt your data at rest.
-     */
-    keyName: string;
-    /**
-     * The version of your Azure Key Vault key to be used to encrypt your data at rest.
-     */
-    keyVersion: string;
-    /**
-     * The URI of your Azure Key Vault, also referred to as DNS name, that contains the key to be
-     * used to encrypt your data at rest. An example URI might be
-     * https://my-keyvault-name.vault.azure.net.
-     */
-    vaultUrl: string;
-    /**
-     * An AAD Application ID that was granted the required access permissions to the Azure Key Vault
-     * that is to be used when encrypting your data at rest. The Application ID should not be
-     * confused with the Object ID for your AAD Application.
-     */
-    applicationId?: string;
-    /**
-     * The authentication key of the specified AAD application.
-     */
-    applicationSecret?: string;
-    /**
-     * An explicit managed identity to use for this encryption key. If not specified and the access
-     * credentials property is null, the system-assigned managed identity is used. On update to the
-     * resource, if the explicit identity is unspecified, it remains unchanged. If "none" is specified,
-     * the value of this property is cleared.
-     */
-    identity?: SearchIndexerDataIdentity;
+export declare type SemanticFieldState = string;
+
+/** Describes the title, content, and keywords fields to be used for semantic ranking, captions, highlights, and answers. */
+export declare interface SemanticPrioritizedFields {
+    /** Defines the title field to be used for semantic ranking, captions, highlights, and answers. If you don't have a title field in your index, leave this blank. */
+    titleField?: SemanticField;
+    /** Defines the content fields to be used for semantic ranking, captions, highlights, and answers. For the best result, the selected fields should contain text in natural language form. The order of the fields in the array represents their priority. Fields with lower priority may get truncated if the content is long. */
+    contentFields?: SemanticField[];
+    /** Defines the keyword fields to be used for semantic ranking, captions, highlights, and answers. For the best result, the selected fields should contain a list of keywords. The order of the fields in the array represents their priority. Fields with lower priority may get truncated if the content is long. */
+    keywordsFields?: SemanticField[];
+}
+
+/** Defines parameters for a search index that influence semantic capabilities. */
+export declare interface SemanticSearch {
+    /** Allows you to set the name of a default semantic configuration in your index, making it optional to pass it on as a query parameter every time. */
+    defaultConfigurationName?: string;
+    /** The semantic configurations for the index. */
+    configurations?: SemanticConfiguration[];
 }
 
 /**
- * Contains a document found by a search query, plus associated metadata.
+ * Defines options for semantic search queries
  */
-export declare type SearchResult<TModel extends object, TFields extends SelectFields<TModel> = SelectFields<TModel>> = {
+export declare interface SemanticSearchOptions {
     /**
-     * The relevance score of the document compared to other documents returned by the query.
-     * **NOTE: This property will not be serialized. It can only be populated by the server.**
+     * The name of a semantic configuration that will be used when processing documents for queries of
+     * type semantic.
      */
-    readonly score: number;
+    configurationName?: string;
     /**
-     * The relevance score computed by the semantic ranker for the top search results. Search results are sorted by the RerankerScore first and then by the Score. RerankerScore is only returned for queries of type 'semantic'.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * Allows the user to choose whether a semantic call should fail completely, or to return partial
+     * results (default).
      */
-    readonly rerankerScore?: number;
+    errorMode?: SemanticErrorMode;
     /**
-     * Text fragments from the document that indicate the matching search terms, organized by each
-     * applicable field; null if hit highlighting was not enabled for the query.
-     * **NOTE: This property will not be serialized. It can only be populated by the server.**
-     */
-    readonly highlights?: {
-        [k in SelectFields<TModel>]?: string[];
-    };
-    /**
-     * Captions are the most representative passages from the document relatively to the search query. They are often used as document summary. Captions are only returned for queries of type 'semantic'.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * Allows the user to set an upper bound on the amount of time it takes for semantic enrichment
+     * to finish processing before the request fails.
      */
-    readonly captions?: CaptionResult[];
-    document: NarrowedModel<TModel, TFields>;
+    maxWaitInMilliseconds?: number;
     /**
-     * Contains debugging information that can be used to further explore your search results.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * If set, the query returns answers extracted from key passages in the highest ranked documents.
      */
-    readonly documentDebugInfo?: DocumentDebugInfo[];
-};
-
-/**
- * Response from a get service statistics request. If successful, it includes service level
- * counters and limits.
- */
-export declare interface SearchServiceStatistics {
+    answers?: QueryAnswer;
     /**
-     * Service level resource counters.
+     * If set, the query returns captions extracted from key passages in the highest ranked
+     * documents. When Captions is set to 'extractive', highlighting is enabled by default. Defaults
+     * to 'None'.
      */
-    counters: ServiceCounters;
+    captions?: QueryCaption;
     /**
-     * Service level general limits.
-     */
-    limits: ServiceLimits;
-}
-
-/** Defines how the Suggest API should apply to a group of fields in the index. */
-export declare interface SearchSuggester {
-    /** The name of the suggester. */
-    name: string;
-    /** A value indicating the capabilities of the suggester. */
-    searchMode: "analyzingInfixMatching";
-    /** The list of field names to which the suggester applies. Each field must be searchable. */
-    sourceFields: string[];
-}
-
-/**
- * If `TFields` is never, an untyped string array
- * Otherwise, a narrowed `Fields[]` type to be used elsewhere in the consuming type.
- */
-export declare type SelectArray<TFields = never> = [string] extends [TFields] ? readonly TFields[] : (<T>() => T extends TFields ? true : false) extends <T>() => T extends never ? true : false ? readonly string[] : readonly TFields[];
-
-/**
- * Produces a union of valid Cognitive Search OData $select paths for T
- * using a post-order traversal of the field tree rooted at T.
- */
-export declare type SelectFields<TModel extends object> = (<T>() => T extends TModel ? true : false) extends <T>() => T extends never ? true : false ? string : (<T>() => T extends TModel ? true : false) extends <T>() => T extends any ? true : false ? string : (<T>() => T extends TModel ? true : false) extends <T>() => T extends object ? true : false ? string : TModel extends Array<infer Elem> ? Elem extends object ? SelectFields<Elem> : never : {
-    [Key in keyof TModel]: Key extends string ? NonNullable<TModel[Key]> extends object ? NonNullable<TModel[Key]> extends ExcludedODataTypes ? Key : SelectFields<NonNullable<TModel[Key]>> extends infer NextPaths ? (<T>() => T extends NextPaths ? true : false) extends <T>() => T extends never ? true : false ? Key : NextPaths extends string ? Key | `${Key}/${NextPaths}` : Key : never : Key : never;
-}[keyof TModel & string] & string;
-
-/** Defines a specific configuration to be used in the context of semantic capabilities. */
-export declare interface SemanticConfiguration {
-    /** The name of the semantic configuration. */
-    name: string;
-    /** Describes the title, content, and keyword fields to be used for semantic ranking, captions, highlights, and answers. At least one of the three sub properties (titleField, prioritizedKeywordsFields and prioritizedContentFields) need to be set. */
-    prioritizedFields: PrioritizedFields;
-}
-
-/**
- * Debug options for semantic search queries.
- */
-export declare interface SemanticDebugInfo {
-    /**
-     * The title field that was sent to the semantic enrichment process, as well as how it was used
-     * NOTE: This property will not be serialized. It can only be populated by the server.
-     */
-    readonly titleField?: QueryResultDocumentSemanticField;
-    /**
-     * The content fields that were sent to the semantic enrichment process, as well as how they were used
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * Allows setting a separate search query that will be solely used for semantic reranking,
+     * semantic captions and semantic answers. Is useful for scenarios where there is a need to use
+     * different queries between the base retrieval and ranking phase, and the L2 semantic phase.
      */
-    readonly contentFields?: QueryResultDocumentSemanticField[];
+    semanticQuery?: string;
     /**
-     * The keyword fields that were sent to the semantic enrichment process, as well as how they were used
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * The list of field names used for semantic search.
      */
-    readonly keywordFields?: QueryResultDocumentSemanticField[];
+    semanticFields?: string[];
     /**
-     * The raw concatenated strings that were sent to the semantic enrichment process.
-     * NOTE: This property will not be serialized. It can only be populated by the server.
+     * Enables a debugging tool that can be used to further explore your search results.
      */
-    readonly rerankerInput?: QueryResultDocumentRerankerInput;
-}
-
-/**
- * partial: If the semantic processing fails, partial results still return. The definition of
- * partial results depends on what semantic step failed and what was the reason for failure.
- *
- * fail: If there is an exception during the semantic processing step, the query will fail and
- * return the appropriate HTTP code depending on the error.
- */
-export declare type SemanticErrorHandlingMode = "partial" | "fail";
-
-/** A field that is used as part of the semantic configuration. */
-export declare interface SemanticField {
-    name?: string;
+    debugMode?: QueryDebugMode;
 }
 
-/**
- * used: The field was fully used for semantic enrichment.
- *
- * unused: The field was not used for semantic enrichment.
- *
- * partial: The field was partially used for semantic enrichment.
- */
-export declare type SemanticFieldState = "used" | "unused" | "partial";
+export declare type SemanticSearchResultsType = "baseResults" | "rerankedResults";
 
 /**
- * maxWaitExceeded: If 'semanticMaxWaitInMilliseconds' was set and the semantic processing duration
- * exceeded that value. Only the base results were returned.
+ * Text analytics positive-negative sentiment analysis, scored as a floating point value in a range of zero to 1.
  *
- * capacityOverloaded: The request was throttled. Only the base results were returned.
- *
- * transient: At least one step of the semantic process failed.
+ * @deprecated This skill has been deprecated.
  */
-export declare type SemanticPartialResponseReason = "maxWaitExceeded" | "capacityOverloaded" | "transient";
-
-/**
- * baseResults: Results without any semantic enrichment or reranking.
- *
- * rerankedResults: Results have been reranked with the reranker model and will include semantic
- * captions. They will not include any answers, answers highlights or caption highlights.
- */
-export declare type SemanticPartialResponseType = "baseResults" | "rerankedResults";
-
-/** Defines parameters for a search index that influence semantic capabilities. */
-export declare interface SemanticSettings {
-    /** Allows you to set the name of a default semantic configuration in your index, making it optional to pass it on as a query parameter every time. */
-    defaultConfiguration?: string;
-    /** The semantic configurations for the index. */
-    configurations?: SemanticConfiguration[];
-}
-
-/**
- * This skill is deprecated. Use the V3.SentimentSkill instead.
- *
- * @deprecated
- */
-export declare type SentimentSkill = BaseSearchIndexerSkill & {
+export declare interface SentimentSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.SentimentSkill";
     /** A value indicating which language code to use. Default is en. */
     defaultLanguageCode?: SentimentSkillLanguage;
-};
+}
 
-/**
- * Defines values for SentimentSkillLanguage. \
- * {@link KnownSentimentSkillLanguage} can be used interchangeably with SentimentSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **da**: Danish \
- * **nl**: Dutch \
- * **en**: English \
- * **fi**: Finnish \
- * **fr**: French \
- * **de**: German \
- * **el**: Greek \
- * **it**: Italian \
- * **no**: Norwegian (Bokmaal) \
- * **pl**: Polish \
- * **pt-PT**: Portuguese (Portugal) \
- * **ru**: Russian \
- * **es**: Spanish \
- * **sv**: Swedish \
- * **tr**: Turkish
- */
-export declare type SentimentSkillLanguage = string;
+export declare type SentimentSkillLanguage = "da" | "nl" | "en" | "fi" | "fr" | "de" | "el" | "it" | "no" | "pl" | "pt-PT" | "ru" | "es" | "sv" | "tr";
 
 /** Using the Text Analytics API, evaluates unstructured text and for each record, provides sentiment labels (such as "negative", "neutral" and "positive") based on the highest confidence score found by the service at a sentence and document-level. */
-export declare type SentimentSkillV3 = BaseSearchIndexerSkill & {
+export declare interface SentimentSkillV3 extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.V3.SentimentSkill";
-    /** A value indicating which language code to use. Default is en. */
+    /** A value indicating which language code to use. Default is `en`. */
     defaultLanguageCode?: string;
     /** If set to true, the skill output will include information from Text Analytics for opinion mining, namely targets (nouns or verbs) and their associated assessment (adjective) in the text. Default is false. */
     includeOpinionMining?: boolean;
     /** The version of the model to use when calling the Text Analytics service. It will default to the latest available when not specified. We recommend you do not specify this value unless absolutely necessary. */
     modelVersion?: string;
-};
+}
 
 /** Represents service-level resource counters and quotas. */
 export declare interface ServiceCounters {
@@ -7122,13 +6735,13 @@ export declare interface ServiceLimits {
 }
 
 /** A skill for reshaping the outputs. It creates a complex type to support composite fields (also known as multipart fields). */
-export declare type ShaperSkill = BaseSearchIndexerSkill & {
+export declare interface ShaperSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Util.ShaperSkill";
-};
+}
 
 /** Creates combinations of tokens as a single token. This token filter is implemented using Apache Lucene. */
-export declare type ShingleTokenFilter = BaseTokenFilter & {
+export declare interface ShingleTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.ShingleTokenFilter";
     /** The maximum shingle size. Default and minimum value is 2. */
@@ -7143,7 +6756,7 @@ export declare type ShingleTokenFilter = BaseTokenFilter & {
     tokenSeparator?: string;
     /** The string to insert for each position at which there is no token. Default is an underscore ("_"). */
     filterToken?: string;
-};
+}
 
 /** Base type for similarity algorithms. Similarity algorithms are used to calculate scores that tie queries to documents. The higher the score, the more relevant the document is to that specific query. Those scores are used to rank the search results. */
 export declare interface Similarity {
@@ -7182,14 +6795,25 @@ export declare interface SimpleField {
      */
     key?: boolean;
     /**
-     * A value indicating whether the field can be returned in a search result. You can enable this
+     * A value indicating whether the field can be returned in a search result. You can disable this
      * option if you want to use a field (for example, margin) as a filter, sorting, or scoring
-     * mechanism but do not want the field to be visible to the end user. This property must be false
-     * for key fields. This property can be changed on existing fields.
-     * Disabling this property does not cause any increase in index storage requirements.
-     * Default is false.
+     * mechanism but do not want the field to be visible to the end user. This property must be true
+     * for key fields. This property can be changed on existing fields. Enabling this property does
+     * not cause any increase in index storage requirements. Default is true for simple fields and
+     * false for vector fields.
      */
     hidden?: boolean;
+    /**
+     * An immutable value indicating whether the field will be persisted separately on disk to be
+     * returned in a search result. You can disable this option if you don't plan to return the field
+     * contents in a search response to save on storage overhead. This can only be set during index
+     * creation and only for vector fields. This property cannot be changed for existing fields or set
+     * as false for new fields. If this property is set as false, the property `hidden` must be set as
+     * true. This property must be true or unset for key fields, for new fields, and for non-vector
+     * fields, and it must be null for complex fields. Disabling this property will reduce index
+     * storage requirements. The default is true for vector fields.
+     */
+    stored?: boolean;
     /**
      * A value indicating whether the field is full-text searchable. This means it will undergo
      * analysis such as word-breaking during indexing. If you set a searchable field to a value like
@@ -7269,29 +6893,29 @@ export declare interface SimpleField {
      * The name of the vector search algorithm configuration that specifies the algorithm and
      * optional parameters for searching the vector field.
      */
-    vectorSearchProfile?: string;
+    vectorSearchProfileName?: string;
 }
 
 /** A filter that stems words using a Snowball-generated stemmer. This token filter is implemented using Apache Lucene. */
-export declare type SnowballTokenFilter = BaseTokenFilter & {
+export declare interface SnowballTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.SnowballTokenFilter";
     /** The language to use. */
     language: SnowballTokenFilterLanguage;
-};
+}
 
 /** Defines values for SnowballTokenFilterLanguage. */
 export declare type SnowballTokenFilterLanguage = "armenian" | "basque" | "catalan" | "danish" | "dutch" | "english" | "finnish" | "french" | "german" | "german2" | "hungarian" | "italian" | "kp" | "lovins" | "norwegian" | "porter" | "portuguese" | "romanian" | "russian" | "spanish" | "swedish" | "turkish";
 
 /** Defines a data deletion detection policy that implements a soft-deletion strategy. It determines whether an item should be deleted based on the value of a designated 'soft delete' column. */
-export declare type SoftDeleteColumnDeletionDetectionPolicy = BaseDataDeletionDetectionPolicy & {
+export declare interface SoftDeleteColumnDeletionDetectionPolicy extends BaseDataDeletionDetectionPolicy {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.SoftDeleteColumnDeletionDetectionPolicy";
     /** The name of the column to use for soft-deletion detection. */
     softDeleteColumnName?: string;
     /** The marker value that identifies an item as deleted. */
     softDeleteMarkerValue?: string;
-};
+}
 
 /**
  * Defines values for Speller. \
@@ -7304,7 +6928,7 @@ export declare type SoftDeleteColumnDeletionDetectionPolicy = BaseDataDeletionDe
 export declare type Speller = string;
 
 /** A skill to split a string into chunks of text. */
-export declare type SplitSkill = BaseSearchIndexerSkill & {
+export declare interface SplitSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.SplitSkill";
     /** A value indicating which language code to use. Default is en. */
@@ -7313,67 +6937,48 @@ export declare type SplitSkill = BaseSearchIndexerSkill & {
     textSplitMode?: TextSplitMode;
     /** The desired maximum page length. Default is 10000. */
     maxPageLength?: number;
-    /** Only applicable when textSplitMode is set to 'pages'. If specified, n+1th chunk will start with this number of characters/tokens from the end of the nth chunk. */
-    pageOverlapLength?: number;
-    /** Only applicable when textSplitMode is set to 'pages'. If specified, the SplitSkill will discontinue splitting after processing the first 'maximumPagesToTake' pages, in order to improve performance when only a few initial pages are needed from each document. */
-    maximumPagesToTake?: number;
-};
+}
 
-/**
- * Defines values for SplitSkillLanguage. \
- * {@link KnownSplitSkillLanguage} can be used interchangeably with SplitSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **da**: Danish \
- * **de**: German \
- * **en**: English \
- * **es**: Spanish \
- * **fi**: Finnish \
- * **fr**: French \
- * **it**: Italian \
- * **ko**: Korean \
- * **pt**: Portuguese
- */
-export declare type SplitSkillLanguage = string;
+export declare type SplitSkillLanguage = "am" | "bs" | "cs" | "da" | "de" | "en" | "es" | "et" | "fi" | "fr" | "he" | "hi" | "hr" | "hu" | "id" | "is" | "it" | "ja" | "ko" | "lv" | "nb" | "nl" | "pl" | "pt" | "pt-br" | "ru" | "sk" | "sl" | "sr" | "sv" | "tr" | "ur" | "zh";
 
 /** Defines a data change detection policy that captures changes using the Integrated Change Tracking feature of Azure SQL Database. */
-export declare type SqlIntegratedChangeTrackingPolicy = BaseDataChangeDetectionPolicy & {
+export declare interface SqlIntegratedChangeTrackingPolicy extends BaseDataChangeDetectionPolicy {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.SqlIntegratedChangeTrackingPolicy";
-};
+}
 
 /** Provides the ability to override other stemming filters with custom dictionary-based stemming. Any dictionary-stemmed terms will be marked as keywords so that they will not be stemmed with stemmers down the chain. Must be placed before any stemming filters. This token filter is implemented using Apache Lucene. */
-export declare type StemmerOverrideTokenFilter = BaseTokenFilter & {
+export declare interface StemmerOverrideTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.StemmerOverrideTokenFilter";
     /** A list of stemming rules in the following format: "word => stem", for example: "ran => run". */
     rules: string[];
-};
+}
 
 /** Language specific stemming filter. This token filter is implemented using Apache Lucene. */
-export declare type StemmerTokenFilter = BaseTokenFilter & {
+export declare interface StemmerTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.StemmerTokenFilter";
     /** The language to use. */
     language: StemmerTokenFilterLanguage;
-};
+}
 
 /** Defines values for StemmerTokenFilterLanguage. */
 export declare type StemmerTokenFilterLanguage = "arabic" | "armenian" | "basque" | "brazilian" | "bulgarian" | "catalan" | "czech" | "danish" | "dutch" | "dutchKp" | "english" | "lightEnglish" | "minimalEnglish" | "possessiveEnglish" | "porter2" | "lovins" | "finnish" | "lightFinnish" | "french" | "lightFrench" | "minimalFrench" | "galician" | "minimalGalician" | "german" | "german2" | "lightGerman" | "minimalGerman" | "greek" | "hindi" | "hungarian" | "lightHungarian" | "indonesian" | "irish" | "italian" | "lightItalian" | "sorani" | "latvian" | "norwegian" | "lightNorwegian" | "minimalNorwegian" | "lightNynorsk" | "minimalNynorsk" | "portuguese" | "lightPortuguese" | "minimalPortuguese" | "portugueseRslp" | "romanian" | "russian" | "lightRussian" | "spanish" | "lightSpanish" | "swedish" | "lightSwedish" | "turkish";
 
 /** Divides text at non-letters; Applies the lowercase and stopword token filters. This analyzer is implemented using Apache Lucene. */
-export declare type StopAnalyzer = BaseLexicalAnalyzer & {
+export declare interface StopAnalyzer extends BaseLexicalAnalyzer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.StopAnalyzer";
     /** A list of stopwords. */
     stopwords?: string[];
-};
+}
 
 /** Defines values for StopwordsList. */
 export declare type StopwordsList = "arabic" | "armenian" | "basque" | "brazilian" | "bulgarian" | "catalan" | "czech" | "danish" | "dutch" | "english" | "finnish" | "french" | "galician" | "german" | "greek" | "hindi" | "hungarian" | "indonesian" | "irish" | "italian" | "latvian" | "norwegian" | "persian" | "portuguese" | "romanian" | "russian" | "sorani" | "spanish" | "swedish" | "thai" | "turkish";
 
 /** Removes stop words from a token stream. This token filter is implemented using Apache Lucene. */
-export declare type StopwordsTokenFilter = BaseTokenFilter & {
+export declare interface StopwordsTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.StopwordsTokenFilter";
     /** The list of stopwords. This property and the stopwords list property cannot both be set. */
@@ -7384,7 +6989,7 @@ export declare type StopwordsTokenFilter = BaseTokenFilter & {
     ignoreCase?: boolean;
     /** A value indicating whether to ignore the last search term if it's a stop word. Default is true. */
     removeTrailingStopWords?: boolean;
-};
+}
 
 /**
  * Response containing suggestion query results from an index.
@@ -7512,7 +7117,7 @@ export declare interface SynonymMap {
 }
 
 /** Matches single or multi-word synonyms in a token stream. This token filter is implemented using Apache Lucene. */
-export declare type SynonymTokenFilter = BaseTokenFilter & {
+export declare interface SynonymTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.SynonymTokenFilter";
     /** A list of synonyms in following one of two formats: 1. incredible, unbelievable, fabulous => amazing - all terms on the left side of => symbol will be replaced with all terms on its right side; 2. incredible, unbelievable, fabulous, amazing - comma separated list of equivalent words. Set the expand option to change how this list is interpreted. */
@@ -7521,15 +7126,15 @@ export declare type SynonymTokenFilter = BaseTokenFilter & {
     ignoreCase?: boolean;
     /** A value indicating whether all words in the list of synonyms (if => notation is not used) will map to one another. If true, all words in the list of synonyms (if => notation is not used) will map to one another. The following list: incredible, unbelievable, fabulous, amazing is equivalent to: incredible, unbelievable, fabulous, amazing => incredible, unbelievable, fabulous, amazing. If false, the following list: incredible, unbelievable, fabulous, amazing will be equivalent to: incredible, unbelievable, fabulous, amazing => incredible. Default is true. */
     expand?: boolean;
-};
+}
 
 /** Defines a function that boosts scores of documents with string values matching a given list of tags. */
-export declare type TagScoringFunction = BaseScoringFunction & {
+export declare interface TagScoringFunction extends BaseScoringFunction {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     type: "tag";
     /** Parameter values for the tag scoring function. */
     parameters: TagScoringParameters;
-};
+}
 
 /** Provides parameter values to a tag scoring function. */
 export declare interface TagScoringParameters {
@@ -7537,18 +7142,10 @@ export declare interface TagScoringParameters {
     tagsParameter: string;
 }
 
-/**
- * Defines values for TextSplitMode. \
- * {@link KnownTextSplitMode} can be used interchangeably with TextSplitMode,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **pages**: Split the text into individual pages. \
- * **sentences**: Split the text into individual sentences.
- */
-export declare type TextSplitMode = string;
+export declare type TextSplitMode = "pages" | "sentences";
 
 /** A skill to translate text from one language to another. */
-export declare type TextTranslationSkill = BaseSearchIndexerSkill & {
+export declare interface TextTranslationSkill extends BaseSearchIndexerSkill {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Skills.Text.TranslationSkill";
     /** The language code to translate documents into for documents that don't specify the to language explicitly. */
@@ -7557,87 +7154,9 @@ export declare type TextTranslationSkill = BaseSearchIndexerSkill & {
     defaultFromLanguageCode?: TextTranslationSkillLanguage;
     /** The language code to translate documents from when neither the fromLanguageCode input nor the defaultFromLanguageCode parameter are provided, and the automatic language detection is unsuccessful. Default is en. */
     suggestedFrom?: TextTranslationSkillLanguage;
-};
+}
 
-/**
- * Defines values for TextTranslationSkillLanguage. \
- * {@link KnownTextTranslationSkillLanguage} can be used interchangeably with TextTranslationSkillLanguage,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **af**: Afrikaans \
- * **ar**: Arabic \
- * **bn**: Bangla \
- * **bs**: Bosnian (Latin) \
- * **bg**: Bulgarian \
- * **yue**: Cantonese (Traditional) \
- * **ca**: Catalan \
- * **zh-Hans**: Chinese Simplified \
- * **zh-Hant**: Chinese Traditional \
- * **hr**: Croatian \
- * **cs**: Czech \
- * **da**: Danish \
- * **nl**: Dutch \
- * **en**: English \
- * **et**: Estonian \
- * **fj**: Fijian \
- * **fil**: Filipino \
- * **fi**: Finnish \
- * **fr**: French \
- * **de**: German \
- * **el**: Greek \
- * **ht**: Haitian Creole \
- * **he**: Hebrew \
- * **hi**: Hindi \
- * **mww**: Hmong Daw \
- * **hu**: Hungarian \
- * **is**: Icelandic \
- * **id**: Indonesian \
- * **it**: Italian \
- * **ja**: Japanese \
- * **sw**: Kiswahili \
- * **tlh**: Klingon \
- * **tlh-Latn**: Klingon (Latin script) \
- * **tlh-Piqd**: Klingon (Klingon script) \
- * **ko**: Korean \
- * **lv**: Latvian \
- * **lt**: Lithuanian \
- * **mg**: Malagasy \
- * **ms**: Malay \
- * **mt**: Maltese \
- * **nb**: Norwegian \
- * **fa**: Persian \
- * **pl**: Polish \
- * **pt**: Portuguese \
- * **pt-br**: Portuguese (Brazil) \
- * **pt-PT**: Portuguese (Portugal) \
- * **otq**: Queretaro Otomi \
- * **ro**: Romanian \
- * **ru**: Russian \
- * **sm**: Samoan \
- * **sr-Cyrl**: Serbian (Cyrillic) \
- * **sr-Latn**: Serbian (Latin) \
- * **sk**: Slovak \
- * **sl**: Slovenian \
- * **es**: Spanish \
- * **sv**: Swedish \
- * **ty**: Tahitian \
- * **ta**: Tamil \
- * **te**: Telugu \
- * **th**: Thai \
- * **to**: Tongan \
- * **tr**: Turkish \
- * **uk**: Ukrainian \
- * **ur**: Urdu \
- * **vi**: Vietnamese \
- * **cy**: Welsh \
- * **yua**: Yucatec Maya \
- * **ga**: Irish \
- * **kn**: Kannada \
- * **mi**: Maori \
- * **ml**: Malayalam \
- * **pa**: Punjabi
- */
-export declare type TextTranslationSkillLanguage = string;
+export declare type TextTranslationSkillLanguage = "af" | "ar" | "bn" | "bs" | "bg" | "yue" | "ca" | "zh-Hans" | "zh-Hant" | "hr" | "cs" | "da" | "nl" | "en" | "et" | "fj" | "fil" | "fi" | "fr" | "de" | "el" | "ht" | "he" | "hi" | "mww" | "hu" | "is" | "id" | "it" | "ja" | "sw" | "tlh" | "tlh-Latn" | "tlh-Piqd" | "ko" | "lv" | "lt" | "mg" | "ms" | "mt" | "nb" | "fa" | "pl" | "pt" | "pt-br" | "pt-PT" | "otq" | "ro" | "ru" | "sm" | "sr-Cyrl" | "sr-Latn" | "sk" | "sl" | "es" | "sv" | "ty" | "ta" | "te" | "th" | "to" | "tr" | "uk" | "ur" | "vi" | "cy" | "yua" | "ga" | "kn" | "mi" | "ml" | "pa";
 
 /** Defines weights on index fields for which matches should boost scoring in search queries. */
 export declare interface TextWeights {
@@ -7698,39 +7217,36 @@ export declare type TokenFilter = AsciiFoldingTokenFilter | CjkBigramTokenFilter
 export declare type TokenFilterName = string;
 
 /** Truncates the terms to a specific length. This token filter is implemented using Apache Lucene. */
-export declare type TruncateTokenFilter = BaseTokenFilter & {
+export declare interface TruncateTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.TruncateTokenFilter";
     /** The length at which terms will be truncated. Default and maximum is 300. */
     length?: number;
-};
+}
 
 /** Tokenizes urls and emails as one token. This tokenizer is implemented using Apache Lucene. */
-export declare type UaxUrlEmailTokenizer = BaseLexicalTokenizer & {
+export declare interface UaxUrlEmailTokenizer extends BaseLexicalTokenizer {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.UaxUrlEmailTokenizer";
     /** The maximum token length. Default is 255. Tokens longer than the maximum length are split. The maximum token length that can be used is 300 characters. */
     maxTokenLength?: number;
-};
+}
 
 export declare type UnionToIntersection<Union> = (Union extends unknown ? (_: Union) => unknown : never) extends (_: infer I) => unknown ? I : never;
 
 /** Filters out tokens with same text as the previous token. This token filter is implemented using Apache Lucene. */
-export declare type UniqueTokenFilter = BaseTokenFilter & {
+export declare interface UniqueTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.UniqueTokenFilter";
     /** A value indicating whether to remove duplicates only at the same position. Default is false. */
     onlyOnSamePosition?: boolean;
-};
+}
 
 /**
  * Options for the upload documents operation.
  */
 export declare type UploadDocumentsOptions = IndexDocumentsOptions;
 
-/**
- * Determines whether or not filters are applied before or after the vector search is performed.
- */
 export declare type VectorFilterMode = "postFilter" | "preFilter";
 
 /** The query parameters to use for vector search when a text value that needs to be vectorized is provided. */
@@ -7741,8 +7257,16 @@ export declare interface VectorizableTextQuery<TModel extends object> extends Ba
     text?: string;
 }
 
+/** The query parameters to use for vector search when a raw vector value is provided. */
+export declare interface VectorizedQuery<TModel extends object> extends BaseVectorQuery<TModel> {
+    /** Polymorphic discriminator, which specifies the different types this object can be */
+    kind: "vector";
+    /** The vector representation of a search query. */
+    vector: number[];
+}
+
 /** The query parameters for vector and hybrid search queries. */
-export declare type VectorQuery<TModel extends object> = RawVectorQuery<TModel> | VectorizableTextQuery<TModel>;
+export declare type VectorQuery<TModel extends object> = VectorizedQuery<TModel> | VectorizableTextQuery<TModel>;
 
 export declare type VectorQueryKind = "vector" | "text";
 
@@ -7754,24 +7278,69 @@ export declare interface VectorSearch {
     algorithms?: VectorSearchAlgorithmConfiguration[];
     /** Contains configuration options on how to vectorize text vector queries. */
     vectorizers?: VectorSearchVectorizer[];
+    /**
+     * Contains configuration options specific to the compression method used during indexing or
+     * querying.
+     */
+    compressions?: VectorSearchCompressionConfiguration[];
 }
 
 /** Contains configuration options specific to the algorithm used during indexing and/or querying. */
-export declare type VectorSearchAlgorithmConfiguration = HnswVectorSearchAlgorithmConfiguration | ExhaustiveKnnVectorSearchAlgorithmConfiguration;
+export declare type VectorSearchAlgorithmConfiguration = HnswAlgorithmConfiguration | ExhaustiveKnnAlgorithmConfiguration;
 
 export declare type VectorSearchAlgorithmKind = "hnsw" | "exhaustiveKnn";
 
-/** The similarity metric to use for vector comparisons. */
 export declare type VectorSearchAlgorithmMetric = "cosine" | "euclidean" | "dotProduct";
 
+/**
+ * Contains configuration options specific to the compression method used during indexing or
+ * querying.
+ */
+export declare type VectorSearchCompressionConfiguration = ScalarQuantizationCompressionConfiguration;
+
+/**
+ * Defines values for VectorSearchCompressionKind. \
+ * {@link KnownVectorSearchCompressionKind} can be used interchangeably with VectorSearchCompressionKind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **scalarQuantization**: Scalar Quantization, a type of compression method. In scalar quantization, the original vectors values are compressed to a narrower type by discretizing and representing each component of a vector using a reduced set of quantized values, thereby reducing the overall data size.
+ */
+export declare type VectorSearchCompressionKind = string;
+
+/**
+ * Defines values for VectorSearchCompressionTargetDataType. \
+ * {@link KnownVectorSearchCompressionTargetDataType} can be used interchangeably with VectorSearchCompressionTargetDataType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **int8**
+ */
+export declare type VectorSearchCompressionTargetDataType = string;
+
+/**
+ * Defines options for vector search queries
+ */
+export declare interface VectorSearchOptions<TModel extends object> {
+    /**
+     * The query parameters for vector, hybrid, and multi-vector search queries.
+     */
+    queries: VectorQuery<TModel>[];
+    /**
+     * Determines whether or not filters are applied before or after the vector search is performed.
+     * Default is 'preFilter'.
+     */
+    filterMode?: VectorFilterMode;
+}
+
 /** Defines a combination of configurations to use with vector search. */
 export declare interface VectorSearchProfile {
     /** The name to associate with this particular vector search profile. */
     name: string;
     /** The name of the vector search algorithm configuration that specifies the algorithm and optional parameters. */
-    algorithm: string;
+    algorithmConfigurationName: string;
     /** The name of the kind of vectorization method being configured for use with vector search. */
     vectorizer?: string;
+    /** The name of the compression method configuration that specifies the compression method and optional parameters. */
+    compressionConfigurationName?: string;
 }
 
 /** Contains configuration options on how to vectorize text vector queries. */
@@ -7779,20 +7348,7 @@ export declare type VectorSearchVectorizer = AzureOpenAIVectorizer | CustomVecto
 
 export declare type VectorSearchVectorizerKind = "azureOpenAI" | "customWebApi";
 
-/**
- * Defines values for VisualFeature. \
- * {@link KnownVisualFeature} can be used interchangeably with VisualFeature,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **adult**: Visual features recognized as adult persons. \
- * **brands**: Visual features recognized as commercial brands. \
- * **categories**: Categories. \
- * **description**: Description. \
- * **faces**: Visual features recognized as people faces. \
- * **objects**: Visual features recognized as objects. \
- * **tags**: Tags.
- */
-export declare type VisualFeature = string;
+export declare type VisualFeature = "adult" | "brands" | "categories" | "description" | "faces" | "objects" | "tags";
 
 /**
  * A skill that can call a Web API endpoint, allowing you to extend a skillset by having it call
@@ -7848,7 +7404,7 @@ export declare interface WebApiSkill extends BaseSearchIndexerSkill {
 }
 
 /** Splits words into subwords and performs optional transformations on subword groups. This token filter is implemented using Apache Lucene. */
-export declare type WordDelimiterTokenFilter = BaseTokenFilter & {
+export declare interface WordDelimiterTokenFilter extends BaseTokenFilter {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     odatatype: "#Microsoft.Azure.Search.WordDelimiterTokenFilter";
     /** A value indicating whether to generate part words. If set, causes parts of words to be generated; for example "AzureSearch" becomes "Azure" "Search". Default is true. */
@@ -7871,6 +7427,6 @@ export declare type WordDelimiterTokenFilter = BaseTokenFilter & {
     stemEnglishPossessive?: boolean;
     /** A list of tokens to protect from being delimited. */
     protectedWords?: string[];
-};
+}
 
 export { }