@azure/search-documents
Version:
Azure client library to use AI Search for node.js and browser.
1,119 lines • 50.3 kB
JavaScript
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { synonymMapSerializer, synonymMapDeserializer, listSynonymMapsResultDeserializer, searchIndexSerializer, searchIndexDeserializer, _listIndexesResultDeserializer, getIndexStatisticsResultDeserializer, analyzeTextOptionsSerializer, analyzeResultDeserializer, searchAliasSerializer, searchAliasDeserializer, _listAliasesResultDeserializer, knowledgeBaseSerializer, knowledgeBaseDeserializer, _listKnowledgeBasesResultDeserializer, knowledgeSourceUnionSerializer, knowledgeSourceUnionDeserializer, _listKnowledgeSourcesResultDeserializer, searchServiceStatisticsDeserializer, } from "../../models/azure/search/documents/indexes/models.js";
import { knowledgeSourceStatusDeserializer } from "../../models/azure/search/documents/knowledgeBases/models.js";
import { errorResponseDeserializer } from "../../models/azure/search/documents/models.js";
import { _listIndexesSelectedResultDeserializer } from "../../models/models.js";
import { buildPagedAsyncIterator } from "../../static-helpers/pagingHelpers.js";
import { expandUrlTemplate } from "../../static-helpers/urlTemplate.js";
import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
export function _getServiceStatisticsSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/servicestats{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getServiceStatisticsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchServiceStatisticsDeserializer(result.body);
}
/** Gets service level statistics for a search service. */
export async function getServiceStatistics(context, options = { requestOptions: {} }) {
const result = await _getServiceStatisticsSend(context, options);
return _getServiceStatisticsDeserialize(result);
}
export function _getKnowledgeSourceStatusSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources('{sourceName}')/status{?api%2Dversion}", {
sourceName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getKnowledgeSourceStatusDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeSourceStatusDeserializer(result.body);
}
/** Retrieves the status of a knowledge source. */
export async function getKnowledgeSourceStatus(context, name, options = { requestOptions: {} }) {
const result = await _getKnowledgeSourceStatusSend(context, name, options);
return _getKnowledgeSourceStatusDeserialize(result);
}
export function _createKnowledgeSourceSend(context, knowledgeSource, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: knowledgeSourceUnionSerializer(knowledgeSource),
});
}
export async function _createKnowledgeSourceDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeSourceUnionDeserializer(result.body);
}
/** Creates a new knowledge source. */
export async function createKnowledgeSource(context, knowledgeSource, options = { requestOptions: {} }) {
const result = await _createKnowledgeSourceSend(context, knowledgeSource, options);
return _createKnowledgeSourceDeserialize(result);
}
export function _listKnowledgeSourcesSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _listKnowledgeSourcesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return _listKnowledgeSourcesResultDeserializer(result.body);
}
/** Lists all knowledge sources available for a search service. */
export function listKnowledgeSources(context, options = { requestOptions: {} }) {
return buildPagedAsyncIterator(context, () => _listKnowledgeSourcesSend(context, options), _listKnowledgeSourcesDeserialize, ["200"], { itemName: "value", apiVersion: context.apiVersion ?? "2026-04-01" });
}
export function _getKnowledgeSourceSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources('{sourceName}'){?api%2Dversion}", {
sourceName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getKnowledgeSourceDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeSourceUnionDeserializer(result.body);
}
/** Retrieves a knowledge source definition. */
export async function getKnowledgeSource(context, name, options = { requestOptions: {} }) {
const result = await _getKnowledgeSourceSend(context, name, options);
return _getKnowledgeSourceDeserialize(result);
}
export function _deleteKnowledgeSourceSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources('{sourceName}'){?api%2Dversion}", {
sourceName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).delete({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _deleteKnowledgeSourceDeserialize(result) {
const expectedStatuses = ["204", "404"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return;
}
/** Deletes an existing knowledge source. */
export async function deleteKnowledgeSource(context, name, options = { requestOptions: {} }) {
const result = await _deleteKnowledgeSourceSend(context, name, options);
return _deleteKnowledgeSourceDeserialize(result);
}
export function _createOrUpdateKnowledgeSourceSend(context, knowledgeSource, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgesources('{sourceName}'){?api%2Dversion}", {
sourceName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).put({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
prefer: "return=representation",
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: knowledgeSourceUnionSerializer(knowledgeSource),
});
}
export async function _createOrUpdateKnowledgeSourceDeserialize(result) {
const expectedStatuses = ["200", "201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeSourceUnionDeserializer(result.body);
}
/** Creates a new knowledge source or updates an knowledge source if it already exists. */
export async function createOrUpdateKnowledgeSource(context, knowledgeSource, name, options = { requestOptions: {} }) {
const result = await _createOrUpdateKnowledgeSourceSend(context, knowledgeSource, name, options);
return _createOrUpdateKnowledgeSourceDeserialize(result);
}
export function _createKnowledgeBaseSend(context, knowledgeBase, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgebases{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: knowledgeBaseSerializer(knowledgeBase),
});
}
export async function _createKnowledgeBaseDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeBaseDeserializer(result.body);
}
/** Creates a new knowledge base. */
export async function createKnowledgeBase(context, knowledgeBase, options = { requestOptions: {} }) {
const result = await _createKnowledgeBaseSend(context, knowledgeBase, options);
return _createKnowledgeBaseDeserialize(result);
}
export function _listKnowledgeBasesSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgebases{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _listKnowledgeBasesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return _listKnowledgeBasesResultDeserializer(result.body);
}
/** Lists all knowledge bases available for a search service. */
export function listKnowledgeBases(context, options = { requestOptions: {} }) {
return buildPagedAsyncIterator(context, () => _listKnowledgeBasesSend(context, options), _listKnowledgeBasesDeserialize, ["200"], { itemName: "value", apiVersion: context.apiVersion ?? "2026-04-01" });
}
export function _getKnowledgeBaseSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgebases('{knowledgeBaseName}'){?api%2Dversion}", {
knowledgeBaseName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getKnowledgeBaseDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeBaseDeserializer(result.body);
}
/** Retrieves a knowledge base definition. */
export async function getKnowledgeBase(context, name, options = { requestOptions: {} }) {
const result = await _getKnowledgeBaseSend(context, name, options);
return _getKnowledgeBaseDeserialize(result);
}
export function _deleteKnowledgeBaseSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgebases('{knowledgeBaseName}'){?api%2Dversion}", {
knowledgeBaseName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).delete({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _deleteKnowledgeBaseDeserialize(result) {
const expectedStatuses = ["204", "404"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return;
}
/** Deletes a knowledge base. */
export async function deleteKnowledgeBase(context, name, options = { requestOptions: {} }) {
const result = await _deleteKnowledgeBaseSend(context, name, options);
return _deleteKnowledgeBaseDeserialize(result);
}
export function _createOrUpdateKnowledgeBaseSend(context, knowledgeBase, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/knowledgebases('{knowledgeBaseName}'){?api%2Dversion}", {
knowledgeBaseName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).put({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
prefer: "return=representation",
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: knowledgeBaseSerializer(knowledgeBase),
});
}
export async function _createOrUpdateKnowledgeBaseDeserialize(result) {
const expectedStatuses = ["200", "201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return knowledgeBaseDeserializer(result.body);
}
/** Creates a new knowledge base or updates a knowledge base if it already exists. */
export async function createOrUpdateKnowledgeBase(context, knowledgeBase, name, options = { requestOptions: {} }) {
const result = await _createOrUpdateKnowledgeBaseSend(context, knowledgeBase, name, options);
return _createOrUpdateKnowledgeBaseDeserialize(result);
}
export function _createAliasSend(context, alias, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/aliases{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: searchAliasSerializer(alias),
});
}
export async function _createAliasDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchAliasDeserializer(result.body);
}
/** Creates a new search alias. */
export async function createAlias(context, alias, options = { requestOptions: {} }) {
const result = await _createAliasSend(context, alias, options);
return _createAliasDeserialize(result);
}
export function _listAliasesSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/aliases{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _listAliasesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return _listAliasesResultDeserializer(result.body);
}
/** Lists all aliases available for a search service. */
export function listAliases(context, options = { requestOptions: {} }) {
return buildPagedAsyncIterator(context, () => _listAliasesSend(context, options), _listAliasesDeserialize, ["200"], { itemName: "aliases", apiVersion: context.apiVersion ?? "2026-04-01" });
}
export function _getAliasSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/aliases('{aliasName}'){?api%2Dversion}", {
aliasName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getAliasDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchAliasDeserializer(result.body);
}
/** Retrieves an alias definition. */
export async function getAlias(context, name, options = { requestOptions: {} }) {
const result = await _getAliasSend(context, name, options);
return _getAliasDeserialize(result);
}
export function _deleteAliasSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/aliases('{aliasName}'){?api%2Dversion}", {
aliasName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).delete({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _deleteAliasDeserialize(result) {
const expectedStatuses = ["204", "404"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return;
}
/** Deletes a search alias and its associated mapping to an index. This operation is permanent, with no recovery option. The mapped index is untouched by this operation. */
export async function deleteAlias(context, name, options = { requestOptions: {} }) {
const result = await _deleteAliasSend(context, name, options);
return _deleteAliasDeserialize(result);
}
export function _createOrUpdateAliasSend(context, alias, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/aliases('{aliasName}'){?api%2Dversion}", {
aliasName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).put({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
prefer: "return=representation",
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: searchAliasSerializer(alias),
});
}
export async function _createOrUpdateAliasDeserialize(result) {
const expectedStatuses = ["200", "201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchAliasDeserializer(result.body);
}
/** Creates a new search alias or updates an alias if it already exists. */
export async function createOrUpdateAlias(context, alias, name, options = { requestOptions: {} }) {
const result = await _createOrUpdateAliasSend(context, alias, name, options);
return _createOrUpdateAliasDeserialize(result);
}
export function _analyzeTextSend(context, request, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes('{indexName}')/search.analyze{?api%2Dversion}", {
indexName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: analyzeTextOptionsSerializer(request),
});
}
export async function _analyzeTextDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return analyzeResultDeserializer(result.body);
}
/** Shows how an analyzer breaks text into tokens. */
export async function analyzeText(context, request, name, options = { requestOptions: {} }) {
const result = await _analyzeTextSend(context, request, name, options);
return _analyzeTextDeserialize(result);
}
export function _getIndexStatisticsSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes('{indexName}')/search.stats{?api%2Dversion}", {
indexName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getIndexStatisticsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return getIndexStatisticsResultDeserializer(result.body);
}
/** Returns statistics for the given index, including a document count and storage usage. */
export async function getIndexStatistics(context, name, options = { requestOptions: {} }) {
const result = await _getIndexStatisticsSend(context, name, options);
return _getIndexStatisticsDeserialize(result);
}
export function _createIndexSend(context, index, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: searchIndexSerializer(index),
});
}
export async function _createIndexDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchIndexDeserializer(result.body);
}
/** Creates a new search index. */
export async function createIndex(context, index, options = { requestOptions: {} }) {
const result = await _createIndexSend(context, index, options);
return _createIndexDeserialize(result);
}
export function _listIndexesWithSelectedPropertiesSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes{?api%2Dversion,%24select}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
"%24select": options?.select,
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _listIndexesWithSelectedPropertiesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return _listIndexesSelectedResultDeserializer(result.body);
}
/** Lists all indexes available for a search service. */
export function listIndexesWithSelectedProperties(context, options = { requestOptions: {} }) {
return buildPagedAsyncIterator(context, () => _listIndexesWithSelectedPropertiesSend(context, options), _listIndexesWithSelectedPropertiesDeserialize, ["200"], { itemName: "value", apiVersion: context.apiVersion ?? "2026-04-01" });
}
export function _listIndexesSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _listIndexesDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return _listIndexesResultDeserializer(result.body);
}
/** Lists all indexes available for a search service. */
export function listIndexes(context, options = { requestOptions: {} }) {
return buildPagedAsyncIterator(context, () => _listIndexesSend(context, options), _listIndexesDeserialize, ["200"], { itemName: "indexes", apiVersion: context.apiVersion ?? "2026-04-01" });
}
export function _getIndexSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes('{indexName}'){?api%2Dversion}", {
indexName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getIndexDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchIndexDeserializer(result.body);
}
/** Retrieves an index definition. */
export async function getIndex(context, name, options = { requestOptions: {} }) {
const result = await _getIndexSend(context, name, options);
return _getIndexDeserialize(result);
}
export function _deleteIndexSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes('{indexName}'){?api%2Dversion}", {
indexName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).delete({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _deleteIndexDeserialize(result) {
const expectedStatuses = ["204", "404"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return;
}
/** Deletes a search index and all the documents it contains. This operation is permanent, with no recovery option. Make sure you have a master copy of your index definition, data ingestion code, and a backup of the primary data source in case you need to re-build the index. */
export async function deleteIndex(context, name, options = { requestOptions: {} }) {
const result = await _deleteIndexSend(context, name, options);
return _deleteIndexDeserialize(result);
}
export function _createOrUpdateIndexSend(context, index, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/indexes('{indexName}'){?api%2Dversion,allowIndexDowntime}", {
indexName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
allowIndexDowntime: options?.allowIndexDowntime,
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).put({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
prefer: "return=representation",
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: searchIndexSerializer(index),
});
}
export async function _createOrUpdateIndexDeserialize(result) {
const expectedStatuses = ["200", "201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return searchIndexDeserializer(result.body);
}
/** Creates a new search index or updates an index if it already exists. */
export async function createOrUpdateIndex(context, index, name, options = { requestOptions: {} }) {
const result = await _createOrUpdateIndexSend(context, index, name, options);
return _createOrUpdateIndexDeserialize(result);
}
export function _createSynonymMapSend(context, synonymMap, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/synonymmaps{?api%2Dversion}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).post({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: synonymMapSerializer(synonymMap),
});
}
export async function _createSynonymMapDeserialize(result) {
const expectedStatuses = ["201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return synonymMapDeserializer(result.body);
}
/** Creates a new synonym map. */
export async function createSynonymMap(context, synonymMap, options = { requestOptions: {} }) {
const result = await _createSynonymMapSend(context, synonymMap, options);
return _createSynonymMapDeserialize(result);
}
export function _getSynonymMapsSend(context, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/synonymmaps{?api%2Dversion,%24select}", {
"api%2Dversion": context.apiVersion ?? "2026-04-01",
"%24select": options?.select,
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getSynonymMapsDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return listSynonymMapsResultDeserializer(result.body);
}
/** Lists all synonym maps available for a search service. */
export async function getSynonymMaps(context, options = { requestOptions: {} }) {
const result = await _getSynonymMapsSend(context, options);
return _getSynonymMapsDeserialize(result);
}
export function _getSynonymMapSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/synonymmaps('{synonymMapName}'){?api%2Dversion}", {
synonymMapName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).get({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _getSynonymMapDeserialize(result) {
const expectedStatuses = ["200"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return synonymMapDeserializer(result.body);
}
/** Retrieves a synonym map definition. */
export async function getSynonymMap(context, name, options = { requestOptions: {} }) {
const result = await _getSynonymMapSend(context, name, options);
return _getSynonymMapDeserialize(result);
}
export function _deleteSynonymMapSend(context, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/synonymmaps('{synonymMapName}'){?api%2Dversion}", {
synonymMapName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).delete({
...operationOptionsToRequestParameters(options),
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
});
}
export async function _deleteSynonymMapDeserialize(result) {
const expectedStatuses = ["204", "404"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return;
}
/** Deletes a synonym map. */
export async function deleteSynonymMap(context, name, options = { requestOptions: {} }) {
const result = await _deleteSynonymMapSend(context, name, options);
return _deleteSynonymMapDeserialize(result);
}
export function _createOrUpdateSynonymMapSend(context, synonymMap, name, options = { requestOptions: {} }) {
const path = expandUrlTemplate("/synonymmaps('{synonymMapName}'){?api%2Dversion}", {
synonymMapName: name,
"api%2Dversion": context.apiVersion ?? "2026-04-01",
}, {
allowReserved: options?.requestOptions?.skipUrlEncoding,
});
return context.path(path).put({
...operationOptionsToRequestParameters(options),
contentType: "application/json",
headers: {
...(options?.accept !== undefined
? {
accept: !options?.accept ? options?.accept : "application/json;odata.metadata=minimal",
}
: {}),
...(options?.ifMatch !== undefined ? { "if-match": options?.ifMatch } : {}),
...(options?.ifNoneMatch !== undefined ? { "if-none-match": options?.ifNoneMatch } : {}),
prefer: "return=representation",
...(options?.clientRequestId !== undefined
? { "x-ms-client-request-id": options?.clientRequestId }
: {}),
...options.requestOptions?.headers,
},
body: synonymMapSerializer(synonymMap),
});
}
export async function _createOrUpdateSynonymMapDeserialize(result) {
const expectedStatuses = ["200", "201"];
if (!expectedStatuses.includes(result.status)) {
const error = createRestError(result);
error.details = errorResponseDeserializer(result.body);
throw error;
}
return synonymMapDeserializer(result.body);
}
/** Creates a new synonym map or updates a synonym map if it already exists. */
export async fu