@azure/search-documents 12.0.0-beta.2 → 12.0.0-beta.4

package/dist/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var tslib = require('tslib');
 var coreRestPipeline = require('@azure/core-rest-pipeline');
 var coreHttpCompat = require('@azure/core-http-compat');
@@ -13,10 +11,7 @@ var EventEmitter = require('events');
 var util = require('util');
 var fs = require('fs');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
         Object.keys(e).forEach(function (k) {
@@ -29,14 +24,13 @@ function _interopNamespace(e) {
             }
         });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
 }
 
-var coreHttpCompat__namespace = /*#__PURE__*/_interopNamespace(coreHttpCompat);
-var coreClient__namespace = /*#__PURE__*/_interopNamespace(coreClient);
-var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var coreHttpCompat__namespace = /*#__PURE__*/_interopNamespaceDefault(coreHttpCompat);
+var coreClient__namespace = /*#__PURE__*/_interopNamespaceDefault(coreClient);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 
 /*
  * Copyright (c) Microsoft Corporation.
@@ -324,6 +318,12 @@ const SearchRequest = {
                     name: "String"
                 }
             },
+            semanticQuery: {
+                serializedName: "semanticQuery",
+                type: {
+                    name: "String"
+                }
+            },
             semanticConfiguration: {
                 serializedName: "semanticConfiguration",
                 type: {
@@ -419,30 +419,42 @@ const SearchRequest = {
                     name: "String"
                 }
             },
-            vector: {
-                serializedName: "vector",
+            vectorQueries: {
+                serializedName: "vectorQueries",
                 type: {
-                    name: "Composite",
-                    className: "Vector"
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "VectorQuery"
+                        }
+                    }
+                }
+            },
+            vectorFilterMode: {
+                serializedName: "vectorFilterMode",
+                type: {
+                    name: "String"
                 }
             }
         }
     }
 };
-const Vector = {
+const VectorQuery = {
     type: {
         name: "Composite",
-        className: "Vector",
+        className: "VectorQuery",
+        uberParent: "VectorQuery",
+        polymorphicDiscriminator: {
+            serializedName: "kind",
+            clientName: "kind"
+        },
         modelProperties: {
-            value: {
-                serializedName: "value",
+            kind: {
+                serializedName: "kind",
+                required: true,
                 type: {
-                    name: "Sequence",
-                    element: {
-                        type: {
-                            name: "Number"
-                        }
-                    }
+                    name: "String"
                 }
             },
             kNearestNeighborsCount: {
@@ -456,6 +468,12 @@ const Vector = {
                 type: {
                     name: "String"
                 }
+            },
+            exhaustive: {
+                serializedName: "exhaustive",
+                type: {
+                    name: "Boolean"
+                }
             }
         }
     }
@@ -1006,31 +1024,74 @@ const AutocompleteRequest = {
         }
     }
 };
+const RawVectorQuery = {
+    serializedName: "vector",
+    type: {
+        name: "Composite",
+        className: "RawVectorQuery",
+        uberParent: "VectorQuery",
+        polymorphicDiscriminator: VectorQuery.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, VectorQuery.type.modelProperties), { vector: {
+                serializedName: "vector",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Number"
+                        }
+                    }
+                }
+            } })
+    }
+};
+const VectorizableTextQuery = {
+    serializedName: "text",
+    type: {
+        name: "Composite",
+        className: "VectorizableTextQuery",
+        uberParent: "VectorQuery",
+        polymorphicDiscriminator: VectorQuery.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, VectorQuery.type.modelProperties), { text: {
+                serializedName: "text",
+                type: {
+                    name: "String"
+                }
+            } })
+    }
+};
+let discriminators$1 = {
+    VectorQuery: VectorQuery,
+    "VectorQuery.vector": RawVectorQuery,
+    "VectorQuery.text": VectorizableTextQuery
+};
 
 var Mappers$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    SearchError: SearchError$1,
-    SearchDocumentsResult: SearchDocumentsResult,
-    FacetResult: FacetResult,
     AnswerResult: AnswerResult,
-    SearchRequest: SearchRequest,
-    Vector: Vector,
-    SearchResult: SearchResult,
+    AutocompleteItem: AutocompleteItem,
+    AutocompleteRequest: AutocompleteRequest,
+    AutocompleteResult: AutocompleteResult,
     CaptionResult: CaptionResult,
     DocumentDebugInfo: DocumentDebugInfo,
-    SemanticDebugInfo: SemanticDebugInfo,
-    QueryResultDocumentSemanticField: QueryResultDocumentSemanticField,
-    QueryResultDocumentRerankerInput: QueryResultDocumentRerankerInput,
-    SuggestDocumentsResult: SuggestDocumentsResult,
-    SuggestResult: SuggestResult,
-    SuggestRequest: SuggestRequest,
-    IndexBatch: IndexBatch,
+    FacetResult: FacetResult,
     IndexAction: IndexAction,
+    IndexBatch: IndexBatch,
     IndexDocumentsResult: IndexDocumentsResult,
     IndexingResult: IndexingResult,
-    AutocompleteResult: AutocompleteResult,
-    AutocompleteItem: AutocompleteItem,
-    AutocompleteRequest: AutocompleteRequest
+    QueryResultDocumentRerankerInput: QueryResultDocumentRerankerInput,
+    QueryResultDocumentSemanticField: QueryResultDocumentSemanticField,
+    RawVectorQuery: RawVectorQuery,
+    SearchDocumentsResult: SearchDocumentsResult,
+    SearchError: SearchError$1,
+    SearchRequest: SearchRequest,
+    SearchResult: SearchResult,
+    SemanticDebugInfo: SemanticDebugInfo,
+    SuggestDocumentsResult: SuggestDocumentsResult,
+    SuggestRequest: SuggestRequest,
+    SuggestResult: SuggestResult,
+    VectorQuery: VectorQuery,
+    VectorizableTextQuery: VectorizableTextQuery,
+    discriminators: discriminators$1
 });
 
 /*
@@ -1215,6 +1276,15 @@ const scoringProfile = {
         }
     }
 };
+const semanticQuery = {
+    parameterPath: ["options", "searchOptions", "semanticQuery"],
+    mapper: {
+        serializedName: "semanticQuery",
+        type: {
+            name: "String"
+        }
+    }
+};
 const semanticConfiguration = {
     parameterPath: ["options", "searchOptions", "semanticConfiguration"],
     mapper: {
@@ -1768,6 +1838,7 @@ const searchGetOperationSpec = {
         queryType,
         scoringParameters,
         scoringProfile,
+        semanticQuery,
         semanticConfiguration,
         semanticErrorHandling,
         semanticMaxWaitInMilliseconds,
@@ -1948,7 +2019,7 @@ const autocompletePostOperationSpec = {
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
 /** @internal */
-class SearchClient$1 extends coreHttpCompat__namespace.ExtendedServiceClient {
+let SearchClient$1 = class SearchClient extends coreHttpCompat__namespace.ExtendedServiceClient {
     /**
      * Initializes a new instance of the SearchClient class.
      * @param endpoint The endpoint URL of the search service.
@@ -1974,7 +2045,7 @@ class SearchClient$1 extends coreHttpCompat__namespace.ExtendedServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-search-documents/12.0.0-beta.2`;
+        const packageDetails = `azsdk-js-search-documents/12.0.0-beta.4`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -1988,7 +2059,7 @@ class SearchClient$1 extends coreHttpCompat__namespace.ExtendedServiceClient {
         this.apiVersion = apiVersion;
         this.documents = new DocumentsImpl(this);
     }
-}
+};
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -2011,12 +2082,14 @@ function createSearchApiKeyCredentialPolicy(credential) {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * The `@azure/logger` configuration for this package.
  */
 const logger = logger$1.createClientLogger("search");
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Creates a tracing client using the global tracer.
  * @internal
@@ -2056,6 +2129,7 @@ class GeographyPoint {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const ISO8601DateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/i;
 const GeoJSONPointTypeName = "Point";
 const WorldGeodeticSystem1984 = "EPSG:4326"; // See https://epsg.io/4326
@@ -2981,6 +3055,7 @@ exports.KnownAnalyzerNames = void 0;
 // END manually modified generated interfaces
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 function convertSkillsToPublic(skills) {
     if (!skills) {
         return skills;
@@ -3274,9 +3349,46 @@ function generatedIndexToPublicIndex(generatedIndex) {
         fields: convertFieldsToPublic(generatedIndex.fields),
         similarity: convertSimilarityToPublic(generatedIndex.similarity),
         semanticSettings: generatedIndex.semanticSettings,
-        vectorSearch: generatedIndex.vectorSearch,
+        vectorSearch: generatedVectorSearchToPublicVectorSearch(generatedIndex.vectorSearch),
     };
 }
+function generatedVectorSearchVectorizerToPublicVectorizer(generatedVectorizer) {
+    if (!generatedVectorizer) {
+        return generatedVectorizer;
+    }
+    if (generatedVectorizer.kind === "azureOpenAI") {
+        const { azureOpenAIParameters } = generatedVectorizer;
+        const authIdentity = convertSearchIndexerDataIdentityToPublic(azureOpenAIParameters === null || azureOpenAIParameters === void 0 ? void 0 : azureOpenAIParameters.authIdentity);
+        const vectorizer = Object.assign(Object.assign({}, generatedVectorizer), { azureOpenAIParameters: Object.assign(Object.assign({}, azureOpenAIParameters), { authIdentity }) });
+        return vectorizer;
+    }
+    if (generatedVectorizer.kind === "customWebApi") {
+        const { customVectorizerParameters } = generatedVectorizer;
+        const authIdentity = convertSearchIndexerDataIdentityToPublic(customVectorizerParameters === null || customVectorizerParameters === void 0 ? void 0 : customVectorizerParameters.authIdentity);
+        const vectorizer = Object.assign(Object.assign({}, generatedVectorizer), { customVectorizerParameters: Object.assign(Object.assign({}, customVectorizerParameters), { authIdentity }) });
+        return vectorizer;
+    }
+    throw Error("Unsupported vectorizer");
+}
+function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
+    var _a;
+    if (!generatedAlgorithmConfiguration) {
+        return generatedAlgorithmConfiguration;
+    }
+    if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
+        const algorithmConfiguration = generatedAlgorithmConfiguration;
+        const metric = (_a = algorithmConfiguration.parameters) === null || _a === void 0 ? void 0 : _a.metric;
+        return Object.assign(Object.assign({}, algorithmConfiguration), { parameters: Object.assign(Object.assign({}, algorithmConfiguration.parameters), { metric }) });
+    }
+    throw Error("Unsupported algorithm configuration");
+}
+function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
+    var _a, _b;
+    if (!vectorSearch) {
+        return vectorSearch;
+    }
+    return Object.assign(Object.assign({}, vectorSearch), { algorithms: (_a = vectorSearch.algorithms) === null || _a === void 0 ? void 0 : _a.map(generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration), vectorizers: (_b = vectorSearch.vectorizers) === null || _b === void 0 ? void 0 : _b.map(generatedVectorSearchVectorizerToPublicVectorizer) });
+}
 function generatedSearchResultToPublicSearchResult(results) {
     const returnValues = results.map((result) => {
         const { _score, _highlights, rerankerScore, captions, documentDebugInfo } = result, restProps = tslib.__rest(result, ["_score", "_highlights", "rerankerScore", "captions", "documentDebugInfo"]);
@@ -3365,8 +3477,9 @@ function generatedSearchIndexerToPublicSearchIndexer(indexer) {
     return Object.assign(Object.assign({}, indexer), { encryptionKey: convertEncryptionKeyToPublic(indexer.encryptionKey), cache: convertSearchIndexerCacheToPublic(indexer.cache) });
 }
 function generatedSearchRequestToPublicSearchRequest(request) {
-    const { semanticErrorHandling, debug, vector } = request, props = tslib.__rest(request, ["semanticErrorHandling", "debug", "vector"]);
-    return Object.assign({ semanticErrorHandlingMode: semanticErrorHandling, debugMode: debug, vector: convertVectorToPublic(vector) }, props);
+    const { semanticErrorHandling, debug, vectorQueries, vectorFilterMode } = request, props = tslib.__rest(request, ["semanticErrorHandling", "debug", "vectorQueries", "vectorFilterMode"]);
+    const publicRequest = Object.assign({ semanticErrorHandlingMode: semanticErrorHandling, debugMode: debug, vectorFilterMode: vectorFilterMode, vectorQueries: vectorQueries === null || vectorQueries === void 0 ? void 0 : vectorQueries.map((convertVectorQueryToPublic)).filter((v) => v !== undefined) }, props);
+    return publicRequest;
 }
 function publicDataSourceToGeneratedDataSource(dataSource) {
     return {
@@ -3427,7 +3540,7 @@ function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy)
     }
     return dataDeletionDetectionPolicy;
 }
-function convertVectorToPublic(vector) {
+function convertVectorQueryToPublic(vector) {
     var _a;
     if (!vector) {
         return vector;
@@ -3453,7 +3566,7 @@ function getRandomIntegerInclusive(min, max) {
 function delay(timeInMs) {
     return new Promise((resolve) => setTimeout(() => resolve(), timeInMs));
 }
-const defaultServiceVersion = "2023-07-01-Preview";
+const defaultServiceVersion = "2023-10-01-Preview";
 function convertKnowledgeStoreToPublic(knowledgeStore) {
     if (!knowledgeStore) {
         return knowledgeStore;
@@ -3489,6 +3602,7 @@ exports.KnownSearchAudience = void 0;
 })(exports.KnownSearchAudience || (exports.KnownSearchAudience = {}));
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Class used to perform operations against a search index,
  * including querying documents in the index as well as
@@ -3662,8 +3776,8 @@ class SearchClient {
         }
     }
     async searchDocuments(searchText, options = {}, nextPageParameters = {}) {
-        const { searchFields, semanticFields, select, orderBy, includeTotalCount, vector, answers, semanticErrorHandlingMode, debugMode } = options, restOptions = tslib.__rest(options, ["searchFields", "semanticFields", "select", "orderBy", "includeTotalCount", "vector", "answers", "semanticErrorHandlingMode", "debugMode"]);
-        const fullOptions = Object.assign(Object.assign(Object.assign({}, restOptions), nextPageParameters), { searchFields: this.convertSearchFields(searchFields), semanticFields: this.convertSemanticFields(semanticFields), select: this.convertSelect(select) || "*", orderBy: this.convertOrderBy(orderBy), includeTotalResultCount: includeTotalCount, vector: this.convertVector(vector), answers: this.convertAnswers(answers), semanticErrorHandling: semanticErrorHandlingMode, debug: debugMode });
+        const { searchFields, semanticFields, select, orderBy, includeTotalCount, vectorQueries, answers, semanticErrorHandlingMode, debugMode } = options, restOptions = tslib.__rest(options, ["searchFields", "semanticFields", "select", "orderBy", "includeTotalCount", "vectorQueries", "answers", "semanticErrorHandlingMode", "debugMode"]);
+        const fullOptions = Object.assign(Object.assign(Object.assign({}, restOptions), nextPageParameters), { searchFields: this.convertSearchFields(searchFields), semanticFields: this.convertSemanticFields(semanticFields), select: this.convertSelect(select) || "*", orderBy: this.convertOrderBy(orderBy), includeTotalResultCount: includeTotalCount, vectorQueries: vectorQueries === null || vectorQueries === void 0 ? void 0 : vectorQueries.map(this.convertVectorQuery.bind(this)), answers: this.convertAnswers(answers), semanticErrorHandling: semanticErrorHandlingMode, debug: debugMode });
         const { span, updatedOptions } = createSpan("SearchClient-searchDocuments", options);
         try {
             const result = await this.client.documents.searchPost(Object.assign(Object.assign({}, fullOptions), { searchText: searchText }), updatedOptions);
@@ -4043,7 +4157,7 @@ class SearchClient {
         }
         return select;
     }
-    convertVectorFields(fields) {
+    convertVectorQueryFields(fields) {
         if (fields) {
             return fields.join(",");
         }
@@ -4087,15 +4201,16 @@ class SearchClient {
         }
         return output;
     }
-    convertVector(vector) {
-        if (!vector) {
-            return vector;
+    convertVectorQuery(vectorQuery) {
+        if (!vectorQuery) {
+            return vectorQuery;
         }
-        return Object.assign(Object.assign({}, vector), { fields: this.convertVectorFields(vector === null || vector === void 0 ? void 0 : vector.fields) });
+        return Object.assign(Object.assign({}, vectorQuery), { fields: this.convertVectorQueryFields(vectorQuery === null || vectorQuery === void 0 ? void 0 : vectorQuery.fields) });
     }
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Default Batch Size
  */
@@ -4129,7 +4244,7 @@ class SearchIndexingBufferedSender {
         /**
          * Event emitter/publisher used in the Buffered Sender
          */
-        this.emitter = new EventEmitter__default["default"]();
+        this.emitter = new EventEmitter();
         this.client = client;
         this.documentKeyRetriever = documentKeyRetriever;
         // General Configuration properties
@@ -5480,6 +5595,13 @@ const SearchIndexerSkillset = {
                     className: "SearchIndexerKnowledgeStore"
                 }
             },
+            indexProjections: {
+                serializedName: "indexProjections",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerIndexProjections"
+                }
+            },
             etag: {
                 serializedName: "@odata\\.etag",
                 type: {
@@ -5677,6 +5799,13 @@ const SearchIndexerKnowledgeStore = {
                     name: "Composite",
                     className: "SearchIndexerDataIdentity"
                 }
+            },
+            parameters: {
+                serializedName: "parameters",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerKnowledgeStoreParameters"
+                }
             }
         }
     }
@@ -5769,6 +5898,107 @@ const SearchIndexerKnowledgeStoreProjectionSelector = {
         }
     }
 };
+const SearchIndexerKnowledgeStoreParameters = {
+    type: {
+        name: "Composite",
+        className: "SearchIndexerKnowledgeStoreParameters",
+        additionalProperties: { type: { name: "Object" } },
+        modelProperties: {
+            synthesizeGeneratedKeyName: {
+                defaultValue: false,
+                serializedName: "synthesizeGeneratedKeyName",
+                type: {
+                    name: "Boolean"
+                }
+            }
+        }
+    }
+};
+const SearchIndexerIndexProjections = {
+    type: {
+        name: "Composite",
+        className: "SearchIndexerIndexProjections",
+        modelProperties: {
+            selectors: {
+                serializedName: "selectors",
+                required: true,
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "SearchIndexerIndexProjectionSelector"
+                        }
+                    }
+                }
+            },
+            parameters: {
+                serializedName: "parameters",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerIndexProjectionsParameters"
+                }
+            }
+        }
+    }
+};
+const SearchIndexerIndexProjectionSelector = {
+    type: {
+        name: "Composite",
+        className: "SearchIndexerIndexProjectionSelector",
+        modelProperties: {
+            targetIndexName: {
+                serializedName: "targetIndexName",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            },
+            parentKeyFieldName: {
+                serializedName: "parentKeyFieldName",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            },
+            sourceContext: {
+                serializedName: "sourceContext",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            },
+            mappings: {
+                serializedName: "mappings",
+                required: true,
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "InputFieldMappingEntry"
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+const SearchIndexerIndexProjectionsParameters = {
+    type: {
+        name: "Composite",
+        className: "SearchIndexerIndexProjectionsParameters",
+        additionalProperties: { type: { name: "Object" } },
+        modelProperties: {
+            projectionMode: {
+                serializedName: "projectionMode",
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
 const ListSkillsetsResult = {
     type: {
         name: "Composite",
@@ -6128,8 +6358,8 @@ const SearchField = {
                     name: "Number"
                 }
             },
-            vectorSearchConfiguration: {
-                serializedName: "vectorSearchConfiguration",
+            vectorSearchProfile: {
+                serializedName: "vectorSearchProfile",
                 nullable: true,
                 type: {
                     name: "String"
@@ -6588,8 +6818,20 @@ const VectorSearch = {
         name: "Composite",
         className: "VectorSearch",
         modelProperties: {
-            algorithmConfigurations: {
-                serializedName: "algorithmConfigurations",
+            profiles: {
+                serializedName: "profiles",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "VectorSearchProfile"
+                        }
+                    }
+                }
+            },
+            algorithms: {
+                serializedName: "algorithms",
                 type: {
                     name: "Sequence",
                     element: {
@@ -6599,6 +6841,46 @@ const VectorSearch = {
                         }
                     }
                 }
+            },
+            vectorizers: {
+                serializedName: "vectorizers",
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
+                            name: "Composite",
+                            className: "VectorSearchVectorizer"
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+const VectorSearchProfile = {
+    type: {
+        name: "Composite",
+        className: "VectorSearchProfile",
+        modelProperties: {
+            name: {
+                serializedName: "name",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            },
+            algorithm: {
+                serializedName: "algorithm",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            },
+            vectorizer: {
+                serializedName: "vectorizer",
+                type: {
+                    name: "String"
+                }
             }
         }
     }
@@ -6630,19 +6912,46 @@ const VectorSearchAlgorithmConfiguration = {
         }
     }
 };
-const ListIndexesResult = {
+const VectorSearchVectorizer = {
     type: {
         name: "Composite",
-        className: "ListIndexesResult",
+        className: "VectorSearchVectorizer",
+        uberParent: "VectorSearchVectorizer",
+        polymorphicDiscriminator: {
+            serializedName: "kind",
+            clientName: "kind"
+        },
         modelProperties: {
-            indexes: {
-                serializedName: "value",
+            name: {
+                serializedName: "name",
                 required: true,
-                readOnly: true,
                 type: {
-                    name: "Sequence",
-                    element: {
-                        type: {
+                    name: "String"
+                }
+            },
+            kind: {
+                serializedName: "kind",
+                required: true,
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const ListIndexesResult = {
+    type: {
+        name: "Composite",
+        className: "ListIndexesResult",
+        modelProperties: {
+            indexes: {
+                serializedName: "value",
+                required: true,
+                readOnly: true,
+                type: {
+                    name: "Sequence",
+                    element: {
+                        type: {
                             name: "Composite",
                             className: "SearchIndex"
                         }
@@ -6675,6 +6984,7 @@ const GetIndexStatisticsResult = {
             },
             vectorIndexSize: {
                 serializedName: "vectorIndexSize",
+                required: true,
                 readOnly: true,
                 type: {
                     name: "Number"
@@ -7056,6 +7366,101 @@ const HnswParameters = {
         }
     }
 };
+const ExhaustiveKnnParameters = {
+    type: {
+        name: "Composite",
+        className: "ExhaustiveKnnParameters",
+        modelProperties: {
+            metric: {
+                serializedName: "metric",
+                nullable: true,
+                type: {
+                    name: "String"
+                }
+            }
+        }
+    }
+};
+const AzureOpenAIParameters = {
+    type: {
+        name: "Composite",
+        className: "AzureOpenAIParameters",
+        modelProperties: {
+            resourceUri: {
+                serializedName: "resourceUri",
+                type: {
+                    name: "String"
+                }
+            },
+            deploymentId: {
+                serializedName: "deploymentId",
+                type: {
+                    name: "String"
+                }
+            },
+            apiKey: {
+                serializedName: "apiKey",
+                type: {
+                    name: "String"
+                }
+            },
+            authIdentity: {
+                serializedName: "authIdentity",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerDataIdentity"
+                }
+            }
+        }
+    }
+};
+const CustomVectorizerParameters = {
+    type: {
+        name: "Composite",
+        className: "CustomVectorizerParameters",
+        modelProperties: {
+            uri: {
+                serializedName: "uri",
+                type: {
+                    name: "String"
+                }
+            },
+            httpHeaders: {
+                serializedName: "httpHeaders",
+                type: {
+                    name: "Dictionary",
+                    value: { type: { name: "String" } }
+                }
+            },
+            httpMethod: {
+                serializedName: "httpMethod",
+                type: {
+                    name: "String"
+                }
+            },
+            timeout: {
+                serializedName: "timeout",
+                type: {
+                    name: "TimeSpan"
+                }
+            },
+            authResourceId: {
+                serializedName: "authResourceId",
+                nullable: true,
+                type: {
+                    name: "String"
+                }
+            },
+            authIdentity: {
+                serializedName: "authIdentity",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerDataIdentity"
+                }
+            }
+        }
+    }
+};
 const DistanceScoringParameters = {
     type: {
         name: "Composite",
@@ -7342,6 +7747,16 @@ const SoftDeleteColumnDeletionDetectionPolicy = {
             } })
     }
 };
+const NativeBlobSoftDeleteDeletionDetectionPolicy = {
+    serializedName: "#Microsoft.Azure.Search.NativeBlobSoftDeleteDeletionDetectionPolicy",
+    type: {
+        name: "Composite",
+        className: "NativeBlobSoftDeleteDeletionDetectionPolicy",
+        uberParent: "DataDeletionDetectionPolicy",
+        polymorphicDiscriminator: DataDeletionDetectionPolicy.type.polymorphicDiscriminator,
+        modelProperties: Object.assign({}, DataDeletionDetectionPolicy.type.modelProperties)
+    }
+};
 const ConditionalSkill = {
     serializedName: "#Microsoft.Skills.Util.ConditionalSkill",
     type: {
@@ -7733,6 +8148,18 @@ const SplitSkill = {
                 type: {
                     name: "Number"
                 }
+            }, pageOverlapLength: {
+                serializedName: "pageOverlapLength",
+                nullable: true,
+                type: {
+                    name: "Number"
+                }
+            }, maximumPagesToTake: {
+                serializedName: "maximumPagesToTake",
+                nullable: true,
+                type: {
+                    name: "Number"
+                }
             } })
     }
 };
@@ -7946,6 +8373,37 @@ const AzureMachineLearningSkill = {
             } })
     }
 };
+const AzureOpenAIEmbeddingSkill = {
+    serializedName: "#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill",
+    type: {
+        name: "Composite",
+        className: "AzureOpenAIEmbeddingSkill",
+        uberParent: "SearchIndexerSkill",
+        polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, SearchIndexerSkill.type.modelProperties), { resourceUri: {
+                serializedName: "resourceUri",
+                type: {
+                    name: "String"
+                }
+            }, deploymentId: {
+                serializedName: "deploymentId",
+                type: {
+                    name: "String"
+                }
+            }, apiKey: {
+                serializedName: "apiKey",
+                type: {
+                    name: "String"
+                }
+            }, authIdentity: {
+                serializedName: "authIdentity",
+                type: {
+                    name: "Composite",
+                    className: "SearchIndexerDataIdentity"
+                }
+            } })
+    }
+};
 const DefaultCognitiveServicesAccount = {
     serializedName: "#Microsoft.Azure.Search.DefaultCognitiveServices",
     type: {
@@ -9570,6 +10028,54 @@ const HnswVectorSearchAlgorithmConfiguration = {
             } })
     }
 };
+const ExhaustiveKnnVectorSearchAlgorithmConfiguration = {
+    serializedName: "exhaustiveKnn",
+    type: {
+        name: "Composite",
+        className: "ExhaustiveKnnVectorSearchAlgorithmConfiguration",
+        uberParent: "VectorSearchAlgorithmConfiguration",
+        polymorphicDiscriminator: VectorSearchAlgorithmConfiguration.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, VectorSearchAlgorithmConfiguration.type.modelProperties), { parameters: {
+                serializedName: "exhaustiveKnnParameters",
+                type: {
+                    name: "Composite",
+                    className: "ExhaustiveKnnParameters"
+                }
+            } })
+    }
+};
+const AzureOpenAIVectorizer = {
+    serializedName: "azureOpenAI",
+    type: {
+        name: "Composite",
+        className: "AzureOpenAIVectorizer",
+        uberParent: "VectorSearchVectorizer",
+        polymorphicDiscriminator: VectorSearchVectorizer.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, VectorSearchVectorizer.type.modelProperties), { azureOpenAIParameters: {
+                serializedName: "azureOpenAIParameters",
+                type: {
+                    name: "Composite",
+                    className: "AzureOpenAIParameters"
+                }
+            } })
+    }
+};
+const CustomVectorizer = {
+    serializedName: "customWebApi",
+    type: {
+        name: "Composite",
+        className: "CustomVectorizer",
+        uberParent: "VectorSearchVectorizer",
+        polymorphicDiscriminator: VectorSearchVectorizer.type.polymorphicDiscriminator,
+        modelProperties: Object.assign(Object.assign({}, VectorSearchVectorizer.type.modelProperties), { customVectorizerParameters: {
+                serializedName: "customVectorizerParameters",
+                type: {
+                    name: "Composite",
+                    className: "CustomVectorizerParameters"
+                }
+            } })
+    }
+};
 const SearchIndexerKnowledgeStoreObjectProjectionSelector = {
     type: {
         name: "Composite",
@@ -9598,11 +10104,13 @@ let discriminators = {
     LexicalNormalizer: LexicalNormalizer,
     Similarity: Similarity,
     VectorSearchAlgorithmConfiguration: VectorSearchAlgorithmConfiguration,
+    VectorSearchVectorizer: VectorSearchVectorizer,
     "SearchIndexerDataIdentity.#Microsoft.Azure.Search.DataNoneIdentity": SearchIndexerDataNoneIdentity,
     "SearchIndexerDataIdentity.#Microsoft.Azure.Search.DataUserAssignedIdentity": SearchIndexerDataUserAssignedIdentity,
     "DataChangeDetectionPolicy.#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy": HighWaterMarkChangeDetectionPolicy,
     "DataChangeDetectionPolicy.#Microsoft.Azure.Search.SqlIntegratedChangeTrackingPolicy": SqlIntegratedChangeTrackingPolicy,
     "DataDeletionDetectionPolicy.#Microsoft.Azure.Search.SoftDeleteColumnDeletionDetectionPolicy": SoftDeleteColumnDeletionDetectionPolicy,
+    "DataDeletionDetectionPolicy.#Microsoft.Azure.Search.NativeBlobSoftDeleteDeletionDetectionPolicy": NativeBlobSoftDeleteDeletionDetectionPolicy,
     "SearchIndexerSkill.#Microsoft.Skills.Util.ConditionalSkill": ConditionalSkill,
     "SearchIndexerSkill.#Microsoft.Skills.Text.KeyPhraseExtractionSkill": KeyPhraseExtractionSkill,
     "SearchIndexerSkill.#Microsoft.Skills.Vision.OcrSkill": OcrSkill,
@@ -9622,6 +10130,7 @@ let discriminators = {
     "SearchIndexerSkill.#Microsoft.Skills.Util.DocumentExtractionSkill": DocumentExtractionSkill,
     "SearchIndexerSkill.#Microsoft.Skills.Custom.WebApiSkill": WebApiSkill,
     "SearchIndexerSkill.#Microsoft.Skills.Custom.AmlSkill": AzureMachineLearningSkill,
+    "SearchIndexerSkill.#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill": AzureOpenAIEmbeddingSkill,
     "CognitiveServicesAccount.#Microsoft.Azure.Search.DefaultCognitiveServices": DefaultCognitiveServicesAccount,
     "CognitiveServicesAccount.#Microsoft.Azure.Search.CognitiveServicesByKey": CognitiveServicesAccountKey,
     "ScoringFunction.distance": DistanceScoringFunction,
@@ -9674,166 +10183,183 @@ let discriminators = {
     "LexicalNormalizer.#Microsoft.Azure.Search.CustomNormalizer": CustomNormalizer,
     "Similarity.#Microsoft.Azure.Search.ClassicSimilarity": ClassicSimilarity,
     "Similarity.#Microsoft.Azure.Search.BM25Similarity": BM25Similarity,
-    "VectorSearchAlgorithmConfiguration.hnsw": HnswVectorSearchAlgorithmConfiguration
+    "VectorSearchAlgorithmConfiguration.hnsw": HnswVectorSearchAlgorithmConfiguration,
+    "VectorSearchAlgorithmConfiguration.exhaustiveKnn": ExhaustiveKnnVectorSearchAlgorithmConfiguration,
+    "VectorSearchVectorizer.azureOpenAI": AzureOpenAIVectorizer,
+    "VectorSearchVectorizer.customWebApi": CustomVectorizer
 };
 
 var Mappers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    SearchIndexerDataSource: SearchIndexerDataSource,
-    DataSourceCredentials: DataSourceCredentials,
-    SearchIndexerDataContainer: SearchIndexerDataContainer,
-    SearchIndexerDataIdentity: SearchIndexerDataIdentity,
-    DataChangeDetectionPolicy: DataChangeDetectionPolicy,
-    DataDeletionDetectionPolicy: DataDeletionDetectionPolicy,
-    SearchResourceEncryptionKey: SearchResourceEncryptionKey,
-    AzureActiveDirectoryApplicationCredentials: AzureActiveDirectoryApplicationCredentials,
-    SearchError: SearchError,
-    ListDataSourcesResult: ListDataSourcesResult,
-    DocumentKeysOrIds: DocumentKeysOrIds,
-    SearchIndexer: SearchIndexer,
-    IndexingSchedule: IndexingSchedule,
-    IndexingParameters: IndexingParameters,
-    IndexingParametersConfiguration: IndexingParametersConfiguration,
-    FieldMapping: FieldMapping,
-    FieldMappingFunction: FieldMappingFunction,
-    SearchIndexerCache: SearchIndexerCache,
-    ListIndexersResult: ListIndexersResult,
-    SearchIndexerStatus: SearchIndexerStatus,
-    IndexerExecutionResult: IndexerExecutionResult,
-    IndexerState: IndexerState,
-    SearchIndexerError: SearchIndexerError,
-    SearchIndexerWarning: SearchIndexerWarning,
-    SearchIndexerLimits: SearchIndexerLimits,
-    SearchIndexerSkillset: SearchIndexerSkillset,
-    SearchIndexerSkill: SearchIndexerSkill,
-    InputFieldMappingEntry: InputFieldMappingEntry,
-    OutputFieldMappingEntry: OutputFieldMappingEntry,
-    CognitiveServicesAccount: CognitiveServicesAccount,
-    SearchIndexerKnowledgeStore: SearchIndexerKnowledgeStore,
-    SearchIndexerKnowledgeStoreProjection: SearchIndexerKnowledgeStoreProjection,
-    SearchIndexerKnowledgeStoreProjectionSelector: SearchIndexerKnowledgeStoreProjectionSelector,
-    ListSkillsetsResult: ListSkillsetsResult,
-    SkillNames: SkillNames,
-    SynonymMap: SynonymMap,
-    ListSynonymMapsResult: ListSynonymMapsResult,
-    SearchIndex: SearchIndex,
-    SearchField: SearchField,
-    ScoringProfile: ScoringProfile,
-    TextWeights: TextWeights,
-    ScoringFunction: ScoringFunction,
-    CorsOptions: CorsOptions,
-    Suggester: Suggester,
-    LexicalAnalyzer: LexicalAnalyzer,
-    LexicalTokenizer: LexicalTokenizer,
-    TokenFilter: TokenFilter,
-    CharFilter: CharFilter,
-    LexicalNormalizer: LexicalNormalizer,
-    Similarity: Similarity,
-    SemanticSettings: SemanticSettings,
-    SemanticConfiguration: SemanticConfiguration,
-    PrioritizedFields: PrioritizedFields,
-    SemanticField: SemanticField,
-    VectorSearch: VectorSearch,
-    VectorSearchAlgorithmConfiguration: VectorSearchAlgorithmConfiguration,
-    ListIndexesResult: ListIndexesResult,
-    GetIndexStatisticsResult: GetIndexStatisticsResult,
     AnalyzeRequest: AnalyzeRequest,
     AnalyzeResult: AnalyzeResult,
     AnalyzedTokenInfo: AnalyzedTokenInfo,
-    SearchAlias: SearchAlias,
-    ListAliasesResult: ListAliasesResult,
-    ServiceStatistics: ServiceStatistics,
-    ServiceCounters: ServiceCounters,
-    ResourceCounter: ResourceCounter,
-    ServiceLimits: ServiceLimits,
-    HnswParameters: HnswParameters,
-    DistanceScoringParameters: DistanceScoringParameters,
-    FreshnessScoringParameters: FreshnessScoringParameters,
-    MagnitudeScoringParameters: MagnitudeScoringParameters,
-    TagScoringParameters: TagScoringParameters,
+    AsciiFoldingTokenFilter: AsciiFoldingTokenFilter,
+    AzureActiveDirectoryApplicationCredentials: AzureActiveDirectoryApplicationCredentials,
+    AzureMachineLearningSkill: AzureMachineLearningSkill,
+    AzureOpenAIEmbeddingSkill: AzureOpenAIEmbeddingSkill,
+    AzureOpenAIParameters: AzureOpenAIParameters,
+    AzureOpenAIVectorizer: AzureOpenAIVectorizer,
+    BM25Similarity: BM25Similarity,
+    CharFilter: CharFilter,
+    CjkBigramTokenFilter: CjkBigramTokenFilter,
+    ClassicSimilarity: ClassicSimilarity,
+    ClassicTokenizer: ClassicTokenizer,
+    CognitiveServicesAccount: CognitiveServicesAccount,
+    CognitiveServicesAccountKey: CognitiveServicesAccountKey,
+    CommonGramTokenFilter: CommonGramTokenFilter,
+    ConditionalSkill: ConditionalSkill,
+    CorsOptions: CorsOptions,
+    CustomAnalyzer: CustomAnalyzer,
     CustomEntity: CustomEntity,
     CustomEntityAlias: CustomEntityAlias,
-    SearchIndexerDataNoneIdentity: SearchIndexerDataNoneIdentity,
-    SearchIndexerDataUserAssignedIdentity: SearchIndexerDataUserAssignedIdentity,
-    HighWaterMarkChangeDetectionPolicy: HighWaterMarkChangeDetectionPolicy,
-    SqlIntegratedChangeTrackingPolicy: SqlIntegratedChangeTrackingPolicy,
-    SoftDeleteColumnDeletionDetectionPolicy: SoftDeleteColumnDeletionDetectionPolicy,
-    ConditionalSkill: ConditionalSkill,
-    KeyPhraseExtractionSkill: KeyPhraseExtractionSkill,
-    OcrSkill: OcrSkill,
-    ImageAnalysisSkill: ImageAnalysisSkill,
-    LanguageDetectionSkill: LanguageDetectionSkill,
-    ShaperSkill: ShaperSkill,
-    MergeSkill: MergeSkill,
-    EntityRecognitionSkill: EntityRecognitionSkill,
-    SentimentSkill: SentimentSkill,
-    SentimentSkillV3: SentimentSkillV3,
-    EntityLinkingSkill: EntityLinkingSkill,
-    EntityRecognitionSkillV3: EntityRecognitionSkillV3,
-    PIIDetectionSkill: PIIDetectionSkill,
-    SplitSkill: SplitSkill,
     CustomEntityLookupSkill: CustomEntityLookupSkill,
-    TextTranslationSkill: TextTranslationSkill,
-    DocumentExtractionSkill: DocumentExtractionSkill,
-    WebApiSkill: WebApiSkill,
-    AzureMachineLearningSkill: AzureMachineLearningSkill,
+    CustomNormalizer: CustomNormalizer,
+    CustomVectorizer: CustomVectorizer,
+    CustomVectorizerParameters: CustomVectorizerParameters,
+    DataChangeDetectionPolicy: DataChangeDetectionPolicy,
+    DataDeletionDetectionPolicy: DataDeletionDetectionPolicy,
+    DataSourceCredentials: DataSourceCredentials,
     DefaultCognitiveServicesAccount: DefaultCognitiveServicesAccount,
-    CognitiveServicesAccountKey: CognitiveServicesAccountKey,
-    SearchIndexerKnowledgeStoreTableProjectionSelector: SearchIndexerKnowledgeStoreTableProjectionSelector,
-    SearchIndexerKnowledgeStoreBlobProjectionSelector: SearchIndexerKnowledgeStoreBlobProjectionSelector,
-    DistanceScoringFunction: DistanceScoringFunction,
-    FreshnessScoringFunction: FreshnessScoringFunction,
-    MagnitudeScoringFunction: MagnitudeScoringFunction,
-    TagScoringFunction: TagScoringFunction,
-    CustomAnalyzer: CustomAnalyzer,
-    PatternAnalyzer: PatternAnalyzer,
-    LuceneStandardAnalyzer: LuceneStandardAnalyzer,
-    StopAnalyzer: StopAnalyzer,
-    ClassicTokenizer: ClassicTokenizer,
-    EdgeNGramTokenizer: EdgeNGramTokenizer,
-    KeywordTokenizer: KeywordTokenizer,
-    KeywordTokenizerV2: KeywordTokenizerV2,
-    MicrosoftLanguageTokenizer: MicrosoftLanguageTokenizer,
-    MicrosoftLanguageStemmingTokenizer: MicrosoftLanguageStemmingTokenizer,
-    NGramTokenizer: NGramTokenizer,
-    PathHierarchyTokenizerV2: PathHierarchyTokenizerV2,
-    PatternTokenizer: PatternTokenizer,
-    LuceneStandardTokenizer: LuceneStandardTokenizer,
-    LuceneStandardTokenizerV2: LuceneStandardTokenizerV2,
-    UaxUrlEmailTokenizer: UaxUrlEmailTokenizer,
-    AsciiFoldingTokenFilter: AsciiFoldingTokenFilter,
-    CjkBigramTokenFilter: CjkBigramTokenFilter,
-    CommonGramTokenFilter: CommonGramTokenFilter,
     DictionaryDecompounderTokenFilter: DictionaryDecompounderTokenFilter,
+    DistanceScoringFunction: DistanceScoringFunction,
+    DistanceScoringParameters: DistanceScoringParameters,
+    DocumentExtractionSkill: DocumentExtractionSkill,
+    DocumentKeysOrIds: DocumentKeysOrIds,
     EdgeNGramTokenFilter: EdgeNGramTokenFilter,
     EdgeNGramTokenFilterV2: EdgeNGramTokenFilterV2,
+    EdgeNGramTokenizer: EdgeNGramTokenizer,
     ElisionTokenFilter: ElisionTokenFilter,
+    EntityLinkingSkill: EntityLinkingSkill,
+    EntityRecognitionSkill: EntityRecognitionSkill,
+    EntityRecognitionSkillV3: EntityRecognitionSkillV3,
+    ExhaustiveKnnParameters: ExhaustiveKnnParameters,
+    ExhaustiveKnnVectorSearchAlgorithmConfiguration: ExhaustiveKnnVectorSearchAlgorithmConfiguration,
+    FieldMapping: FieldMapping,
+    FieldMappingFunction: FieldMappingFunction,
+    FreshnessScoringFunction: FreshnessScoringFunction,
+    FreshnessScoringParameters: FreshnessScoringParameters,
+    GetIndexStatisticsResult: GetIndexStatisticsResult,
+    HighWaterMarkChangeDetectionPolicy: HighWaterMarkChangeDetectionPolicy,
+    HnswParameters: HnswParameters,
+    HnswVectorSearchAlgorithmConfiguration: HnswVectorSearchAlgorithmConfiguration,
+    ImageAnalysisSkill: ImageAnalysisSkill,
+    IndexerExecutionResult: IndexerExecutionResult,
+    IndexerState: IndexerState,
+    IndexingParameters: IndexingParameters,
+    IndexingParametersConfiguration: IndexingParametersConfiguration,
+    IndexingSchedule: IndexingSchedule,
+    InputFieldMappingEntry: InputFieldMappingEntry,
     KeepTokenFilter: KeepTokenFilter,
+    KeyPhraseExtractionSkill: KeyPhraseExtractionSkill,
     KeywordMarkerTokenFilter: KeywordMarkerTokenFilter,
+    KeywordTokenizer: KeywordTokenizer,
+    KeywordTokenizerV2: KeywordTokenizerV2,
+    LanguageDetectionSkill: LanguageDetectionSkill,
     LengthTokenFilter: LengthTokenFilter,
+    LexicalAnalyzer: LexicalAnalyzer,
+    LexicalNormalizer: LexicalNormalizer,
+    LexicalTokenizer: LexicalTokenizer,
     LimitTokenFilter: LimitTokenFilter,
+    ListAliasesResult: ListAliasesResult,
+    ListDataSourcesResult: ListDataSourcesResult,
+    ListIndexersResult: ListIndexersResult,
+    ListIndexesResult: ListIndexesResult,
+    ListSkillsetsResult: ListSkillsetsResult,
+    ListSynonymMapsResult: ListSynonymMapsResult,
+    LuceneStandardAnalyzer: LuceneStandardAnalyzer,
+    LuceneStandardTokenizer: LuceneStandardTokenizer,
+    LuceneStandardTokenizerV2: LuceneStandardTokenizerV2,
+    MagnitudeScoringFunction: MagnitudeScoringFunction,
+    MagnitudeScoringParameters: MagnitudeScoringParameters,
+    MappingCharFilter: MappingCharFilter,
+    MergeSkill: MergeSkill,
+    MicrosoftLanguageStemmingTokenizer: MicrosoftLanguageStemmingTokenizer,
+    MicrosoftLanguageTokenizer: MicrosoftLanguageTokenizer,
     NGramTokenFilter: NGramTokenFilter,
     NGramTokenFilterV2: NGramTokenFilterV2,
+    NGramTokenizer: NGramTokenizer,
+    NativeBlobSoftDeleteDeletionDetectionPolicy: NativeBlobSoftDeleteDeletionDetectionPolicy,
+    OcrSkill: OcrSkill,
+    OutputFieldMappingEntry: OutputFieldMappingEntry,
+    PIIDetectionSkill: PIIDetectionSkill,
+    PathHierarchyTokenizerV2: PathHierarchyTokenizerV2,
+    PatternAnalyzer: PatternAnalyzer,
     PatternCaptureTokenFilter: PatternCaptureTokenFilter,
+    PatternReplaceCharFilter: PatternReplaceCharFilter,
     PatternReplaceTokenFilter: PatternReplaceTokenFilter,
+    PatternTokenizer: PatternTokenizer,
     PhoneticTokenFilter: PhoneticTokenFilter,
+    PrioritizedFields: PrioritizedFields,
+    ResourceCounter: ResourceCounter,
+    ScoringFunction: ScoringFunction,
+    ScoringProfile: ScoringProfile,
+    SearchAlias: SearchAlias,
+    SearchError: SearchError,
+    SearchField: SearchField,
+    SearchIndex: SearchIndex,
+    SearchIndexer: SearchIndexer,
+    SearchIndexerCache: SearchIndexerCache,
+    SearchIndexerDataContainer: SearchIndexerDataContainer,
+    SearchIndexerDataIdentity: SearchIndexerDataIdentity,
+    SearchIndexerDataNoneIdentity: SearchIndexerDataNoneIdentity,
+    SearchIndexerDataSource: SearchIndexerDataSource,
+    SearchIndexerDataUserAssignedIdentity: SearchIndexerDataUserAssignedIdentity,
+    SearchIndexerError: SearchIndexerError,
+    SearchIndexerIndexProjectionSelector: SearchIndexerIndexProjectionSelector,
+    SearchIndexerIndexProjections: SearchIndexerIndexProjections,
+    SearchIndexerIndexProjectionsParameters: SearchIndexerIndexProjectionsParameters,
+    SearchIndexerKnowledgeStore: SearchIndexerKnowledgeStore,
+    SearchIndexerKnowledgeStoreBlobProjectionSelector: SearchIndexerKnowledgeStoreBlobProjectionSelector,
+    SearchIndexerKnowledgeStoreFileProjectionSelector: SearchIndexerKnowledgeStoreFileProjectionSelector,
+    SearchIndexerKnowledgeStoreObjectProjectionSelector: SearchIndexerKnowledgeStoreObjectProjectionSelector,
+    SearchIndexerKnowledgeStoreParameters: SearchIndexerKnowledgeStoreParameters,
+    SearchIndexerKnowledgeStoreProjection: SearchIndexerKnowledgeStoreProjection,
+    SearchIndexerKnowledgeStoreProjectionSelector: SearchIndexerKnowledgeStoreProjectionSelector,
+    SearchIndexerKnowledgeStoreTableProjectionSelector: SearchIndexerKnowledgeStoreTableProjectionSelector,
+    SearchIndexerLimits: SearchIndexerLimits,
+    SearchIndexerSkill: SearchIndexerSkill,
+    SearchIndexerSkillset: SearchIndexerSkillset,
+    SearchIndexerStatus: SearchIndexerStatus,
+    SearchIndexerWarning: SearchIndexerWarning,
+    SearchResourceEncryptionKey: SearchResourceEncryptionKey,
+    SemanticConfiguration: SemanticConfiguration,
+    SemanticField: SemanticField,
+    SemanticSettings: SemanticSettings,
+    SentimentSkill: SentimentSkill,
+    SentimentSkillV3: SentimentSkillV3,
+    ServiceCounters: ServiceCounters,
+    ServiceLimits: ServiceLimits,
+    ServiceStatistics: ServiceStatistics,
+    ShaperSkill: ShaperSkill,
     ShingleTokenFilter: ShingleTokenFilter,
+    Similarity: Similarity,
+    SkillNames: SkillNames,
     SnowballTokenFilter: SnowballTokenFilter,
-    StemmerTokenFilter: StemmerTokenFilter,
+    SoftDeleteColumnDeletionDetectionPolicy: SoftDeleteColumnDeletionDetectionPolicy,
+    SplitSkill: SplitSkill,
+    SqlIntegratedChangeTrackingPolicy: SqlIntegratedChangeTrackingPolicy,
     StemmerOverrideTokenFilter: StemmerOverrideTokenFilter,
+    StemmerTokenFilter: StemmerTokenFilter,
+    StopAnalyzer: StopAnalyzer,
     StopwordsTokenFilter: StopwordsTokenFilter,
+    Suggester: Suggester,
+    SynonymMap: SynonymMap,
     SynonymTokenFilter: SynonymTokenFilter,
+    TagScoringFunction: TagScoringFunction,
+    TagScoringParameters: TagScoringParameters,
+    TextTranslationSkill: TextTranslationSkill,
+    TextWeights: TextWeights,
+    TokenFilter: TokenFilter,
     TruncateTokenFilter: TruncateTokenFilter,
+    UaxUrlEmailTokenizer: UaxUrlEmailTokenizer,
     UniqueTokenFilter: UniqueTokenFilter,
+    VectorSearch: VectorSearch,
+    VectorSearchAlgorithmConfiguration: VectorSearchAlgorithmConfiguration,
+    VectorSearchProfile: VectorSearchProfile,
+    VectorSearchVectorizer: VectorSearchVectorizer,
+    WebApiSkill: WebApiSkill,
     WordDelimiterTokenFilter: WordDelimiterTokenFilter,
-    MappingCharFilter: MappingCharFilter,
-    PatternReplaceCharFilter: PatternReplaceCharFilter,
-    CustomNormalizer: CustomNormalizer,
-    ClassicSimilarity: ClassicSimilarity,
-    BM25Similarity: BM25Similarity,
-    HnswVectorSearchAlgorithmConfiguration: HnswVectorSearchAlgorithmConfiguration,
-    SearchIndexerKnowledgeStoreObjectProjectionSelector: SearchIndexerKnowledgeStoreObjectProjectionSelector,
-    SearchIndexerKnowledgeStoreFileProjectionSelector: SearchIndexerKnowledgeStoreFileProjectionSelector,
     discriminators: discriminators
 });
 
@@ -11207,7 +11733,7 @@ class SearchServiceClient extends coreHttpCompat__namespace.ExtendedServiceClien
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-search-documents/12.0.0-beta.2`;
+        const packageDetails = `azsdk-js-search-documents/12.0.0-beta.4`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -11253,6 +11779,7 @@ const getServiceStatisticsOperationSpec = {
 };
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Class to perform operations to manage
  * (create, update, list/delete)
@@ -11910,6 +12437,7 @@ class SearchIndexClient {
 }
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 /**
  * Class to perform operations to manage
  * (create, update, list/delete)
@@ -12546,12 +13074,12 @@ function odata(strings, ...values) {
  * Code generated by Microsoft (R) AutoRest Code Generator.
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
-/** Known values of {@link ApiVersion20230701Preview} that the service accepts. */
-var KnownApiVersion20230701Preview$1;
-(function (KnownApiVersion20230701Preview) {
-    /** Api Version '2023-07-01-Preview' */
-    KnownApiVersion20230701Preview["TwoThousandTwentyThree0701Preview"] = "2023-07-01-Preview";
-})(KnownApiVersion20230701Preview$1 || (KnownApiVersion20230701Preview$1 = {}));
+/** Known values of {@link ApiVersion20231001Preview} that the service accepts. */
+var KnownApiVersion20231001Preview$1;
+(function (KnownApiVersion20231001Preview) {
+    /** Api Version '2023-10-01-Preview' */
+    KnownApiVersion20231001Preview["TwoThousandTwentyThree1001Preview"] = "2023-10-01-Preview";
+})(KnownApiVersion20231001Preview$1 || (KnownApiVersion20231001Preview$1 = {}));
 /** Known values of {@link SemanticErrorHandling} that the service accepts. */
 var KnownSemanticErrorHandling;
 (function (KnownSemanticErrorHandling) {
@@ -12764,6 +13292,22 @@ exports.KnownQueryCaptionType = void 0;
     /** Extracts captions from the matching documents that contain passages relevant to the search query. */
     KnownQueryCaptionType["Extractive"] = "extractive";
 })(exports.KnownQueryCaptionType || (exports.KnownQueryCaptionType = {}));
+/** Known values of {@link VectorQueryKind} that the service accepts. */
+var KnownVectorQueryKind;
+(function (KnownVectorQueryKind) {
+    /** Vector query where a raw vector value is provided. */
+    KnownVectorQueryKind["Vector"] = "vector";
+    /** Vector query where a text value that needs to be vectorized is provided. */
+    KnownVectorQueryKind["$DO_NOT_NORMALIZE$_text"] = "text";
+})(KnownVectorQueryKind || (KnownVectorQueryKind = {}));
+/** Known values of {@link VectorFilterMode} that the service accepts. */
+var KnownVectorFilterMode;
+(function (KnownVectorFilterMode) {
+    /** The filter will be applied after the candidate set of vector results is returned. Depending on the filter selectivity, this can result in fewer results than requested by the parameter 'k'. */
+    KnownVectorFilterMode["PostFilter"] = "postFilter";
+    /** The filter will be applied before the search query. */
+    KnownVectorFilterMode["PreFilter"] = "preFilter";
+})(KnownVectorFilterMode || (KnownVectorFilterMode = {}));
 /** Known values of {@link SemanticPartialResponseReason} that the service accepts. */
 var KnownSemanticPartialResponseReason;
 (function (KnownSemanticPartialResponseReason) {
@@ -12800,12 +13344,12 @@ var KnownSemanticFieldState;
  * Code generated by Microsoft (R) AutoRest Code Generator.
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
-/** Known values of {@link ApiVersion20230701Preview} that the service accepts. */
-var KnownApiVersion20230701Preview;
-(function (KnownApiVersion20230701Preview) {
-    /** Api Version '2023-07-01-Preview' */
-    KnownApiVersion20230701Preview["TwoThousandTwentyThree0701Preview"] = "2023-07-01-Preview";
-})(KnownApiVersion20230701Preview || (KnownApiVersion20230701Preview = {}));
+/** Known values of {@link ApiVersion20231001Preview} that the service accepts. */
+var KnownApiVersion20231001Preview;
+(function (KnownApiVersion20231001Preview) {
+    /** Api Version '2023-10-01-Preview' */
+    KnownApiVersion20231001Preview["TwoThousandTwentyThree1001Preview"] = "2023-10-01-Preview";
+})(KnownApiVersion20231001Preview || (KnownApiVersion20231001Preview = {}));
 /** Known values of {@link SearchIndexerDataSourceType} that the service accepts. */
 exports.KnownSearchIndexerDataSourceType = void 0;
 (function (KnownSearchIndexerDataSourceType) {
@@ -12888,6 +13432,14 @@ exports.KnownIndexingMode = void 0;
     /** The indexer is indexing selective, reset documents in the datasource. The documents being indexed are defined on indexer status. */
     KnownIndexingMode["IndexingResetDocs"] = "indexingResetDocs";
 })(exports.KnownIndexingMode || (exports.KnownIndexingMode = {}));
+/** Known values of {@link IndexProjectionMode} that the service accepts. */
+var KnownIndexProjectionMode;
+(function (KnownIndexProjectionMode) {
+    /** The source document will be skipped from writing into the indexer's target index. */
+    KnownIndexProjectionMode["SkipIndexingParentDocuments"] = "skipIndexingParentDocuments";
+    /** The source document will be written into the indexer's target index. This is the default pattern. */
+    KnownIndexProjectionMode["IncludeIndexingParentDocuments"] = "includeIndexingParentDocuments";
+})(KnownIndexProjectionMode || (KnownIndexProjectionMode = {}));
 /** Known values of {@link SearchFieldDataType} that the service accepts. */
 var KnownSearchFieldDataType;
 (function (KnownSearchFieldDataType) {
@@ -13114,6 +13666,22 @@ exports.KnownLexicalNormalizerName = void 0;
     /** Normalizes token text to uppercase. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/UpperCaseFilter.html */
     KnownLexicalNormalizerName["Uppercase"] = "uppercase";
 })(exports.KnownLexicalNormalizerName || (exports.KnownLexicalNormalizerName = {}));
+/** Known values of {@link VectorSearchAlgorithmKind} that the service accepts. */
+var KnownVectorSearchAlgorithmKind;
+(function (KnownVectorSearchAlgorithmKind) {
+    /** Hnsw (Hierarchical Navigable Small World), a type of approximate nearest neighbors algorithm. */
+    KnownVectorSearchAlgorithmKind["Hnsw"] = "hnsw";
+    /** Exhaustive KNN algorithm which will perform brute-force search. */
+    KnownVectorSearchAlgorithmKind["ExhaustiveKnn"] = "exhaustiveKnn";
+})(KnownVectorSearchAlgorithmKind || (KnownVectorSearchAlgorithmKind = {}));
+/** Known values of {@link VectorSearchVectorizerKind} that the service accepts. */
+var KnownVectorSearchVectorizerKind;
+(function (KnownVectorSearchVectorizerKind) {
+    /** Generate embeddings using an Azure Open AI service at query time. */
+    KnownVectorSearchVectorizerKind["AzureOpenAI"] = "azureOpenAI";
+    /** Generate embeddings using a custom web endpoint at query time. */
+    KnownVectorSearchVectorizerKind["CustomWebApi"] = "customWebApi";
+})(KnownVectorSearchVectorizerKind || (KnownVectorSearchVectorizerKind = {}));
 /** Known values of {@link TokenFilterName} that the service accepts. */
 exports.KnownTokenFilterName = void 0;
 (function (KnownTokenFilterName) {
@@ -14087,6 +14655,7 @@ exports.KnownRegexFlags = void 0;
 })(exports.KnownRegexFlags || (exports.KnownRegexFlags = {}));
 
 // Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
 const readFileAsync = util.promisify(fs__namespace.readFile);
 /**
  * Helper method to create a SynonymMap object. This is a NodeJS only method.