@azure/search-documents 12.3.0-beta.1 → 13.0.0

package/dist/browser/searchIndex/api/operations.js

@@ -0,0 +1,1123 @@
+// 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 function createOrUpdateSynonymMap(context, synonymMap, name, options = { requestOptions: {} }) {
+    const result = await _createOrUpdateSynonymMapSend(context, synonymMap, name, options);
+    return _createOrUpdateSynonymMapDeserialize(result);
+}
+//# sourceMappingURL=operations.js.map