@azure/search-documents 12.2.0-beta.1 → 12.2.0-beta.3

package/dist/commonjs/searchIndexClient.js

@@ -0,0 +1,955 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchIndexClient = void 0;
+const tslib_1 = require("tslib");
+const core_auth_1 = require("@azure/core-auth");
+const core_rest_pipeline_1 = require("@azure/core-rest-pipeline");
+const searchServiceClient_js_1 = require("./generated/service/searchServiceClient.js");
+const knowledgeRetrievalClient_js_1 = require("./knowledgeRetrievalClient.js");
+const logger_js_1 = require("./logger.js");
+const odataMetadataPolicy_js_1 = require("./odataMetadataPolicy.js");
+const searchApiKeyCredentialPolicy_js_1 = require("./searchApiKeyCredentialPolicy.js");
+const searchAudience_js_1 = require("./searchAudience.js");
+const searchClient_js_1 = require("./searchClient.js");
+const utils = tslib_1.__importStar(require("./serviceUtils.js"));
+const tracing_js_1 = require("./tracing.js");
+/**
+ * Class to perform operations to manage
+ * (create, update, list/delete)
+ * indexes, & synonymmaps.
+ */
+class SearchIndexClient {
+    /**
+     * The API version to use when communicating with the service.
+     */
+    serviceVersion = utils.defaultServiceVersion;
+    /**
+     * The API version to use when communicating with the service.
+     * @deprecated use {@Link serviceVersion} instead
+     */
+    apiVersion = utils.defaultServiceVersion;
+    /**
+     * The endpoint of the search service
+     */
+    endpoint;
+    /**
+     * @hidden
+     * A reference to the auto-generated SearchServiceClient
+     */
+    client;
+    /**
+     * A reference to the internal HTTP pipeline for use with raw requests
+     */
+    pipeline;
+    /**
+     * Used to authenticate requests to the service.
+     */
+    credential;
+    /**
+     * Used to configure the Search Index client.
+     */
+    options;
+    /**
+     * Creates an instance of SearchIndexClient.
+     *
+     * Example usage:
+     * ```ts snippet:ReadmeSampleSearchIndexClient
+     * import { SearchIndexClient, AzureKeyCredential } from "@azure/search-documents";
+     *
+     * const indexClient = new SearchIndexClient("<endpoint>", new AzureKeyCredential("<apiKey>"));
+     * ```
+     * @param endpoint - The endpoint of the search service
+     * @param credential - Used to authenticate requests to the service.
+     * @param options - Used to configure the Search Index client.
+     */
+    constructor(endpoint, credential, options = {}) {
+        this.endpoint = endpoint;
+        this.credential = credential;
+        this.options = options;
+        const internalClientPipelineOptions = {
+            ...this.options,
+            ...{
+                loggingOptions: {
+                    logger: logger_js_1.logger.info,
+                    additionalAllowedHeaderNames: [
+                        "elapsed-time",
+                        "Location",
+                        "OData-MaxVersion",
+                        "OData-Version",
+                        "Prefer",
+                        "throttle-reason",
+                    ],
+                },
+            },
+        };
+        this.serviceVersion =
+            this.options.serviceVersion ?? this.options.apiVersion ?? utils.defaultServiceVersion;
+        this.apiVersion = this.serviceVersion;
+        this.client = new searchServiceClient_js_1.SearchServiceClient(this.endpoint, this.serviceVersion, internalClientPipelineOptions);
+        this.pipeline = this.client.pipeline;
+        if ((0, core_auth_1.isTokenCredential)(credential)) {
+            const scope = this.options.audience
+                ? `${this.options.audience}/.default`
+                : `${searchAudience_js_1.KnownSearchAudience.AzurePublicCloud}/.default`;
+            this.client.pipeline.addPolicy((0, core_rest_pipeline_1.bearerTokenAuthenticationPolicy)({ credential, scopes: scope }));
+        }
+        else {
+            this.client.pipeline.addPolicy((0, searchApiKeyCredentialPolicy_js_1.createSearchApiKeyCredentialPolicy)(credential));
+        }
+        this.client.pipeline.addPolicy((0, odataMetadataPolicy_js_1.createOdataMetadataPolicy)("minimal"));
+    }
+    async *listIndexesPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listIndexesPage", options);
+        try {
+            const result = await this.client.indexes.list(updatedOptions);
+            const mapped = result.indexes.map(utils.generatedIndexToPublicIndex);
+            yield mapped;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listIndexesAll(options = {}) {
+        for await (const page of this.listIndexesPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Retrieves a list of existing indexes in the service.
+     * @param options - Options to the list index operation.
+     */
+    listIndexes(options = {}) {
+        const iter = this.listIndexesAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.listIndexesPage(options);
+            },
+        };
+    }
+    async *listAliasesPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listAliases", options);
+        try {
+            const result = await this.client.aliases.list(updatedOptions);
+            yield result.aliases;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listAliasesAll(options = {}) {
+        for await (const page of this.listAliasesPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Lists all aliases available for a search service.
+     * @param options - The options parameters.
+     */
+    listAliases(options = {}) {
+        const iter = this.listAliasesAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.listAliasesPage(options);
+            },
+        };
+    }
+    async *listIndexesNamesPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listIndexesNamesPage", options);
+        try {
+            const result = await this.client.indexes.list({
+                ...updatedOptions,
+                select: "name",
+            });
+            const mapped = result.indexes.map((idx) => idx.name);
+            yield mapped;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listIndexesNamesAll(options = {}) {
+        for await (const page of this.listIndexesNamesPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Retrieves a list of names of existing indexes in the service.
+     * @param options - Options to the list index operation.
+     */
+    // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+    listIndexesNames(options = {}) {
+        const iter = this.listIndexesNamesAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.listIndexesNamesPage(options);
+            },
+        };
+    }
+    /**
+     * Retrieves a list of existing SynonymMaps in the service.
+     * @param options - Options to the list SynonymMaps operation.
+     */
+    async listSynonymMaps(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listSynonymMaps", options);
+        try {
+            const result = await this.client.synonymMaps.list(updatedOptions);
+            return result.synonymMaps.map(utils.generatedSynonymMapToPublicSynonymMap);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves a list of names of existing SynonymMaps in the service.
+     * @param options - Options to the list SynonymMaps operation.
+     */
+    // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+    async listSynonymMapsNames(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listSynonymMapsNames", options);
+        try {
+            const result = await this.client.synonymMaps.list({
+                ...updatedOptions,
+                select: "name",
+            });
+            return result.synonymMaps.map((sm) => sm.name);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves information about an index.
+     * @param indexName - The name of the index.
+     * @param options - Additional optional arguments.
+     */
+    async getIndex(indexName, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getIndex", options);
+        try {
+            const result = await this.client.indexes.get(indexName, updatedOptions);
+            return utils.generatedIndexToPublicIndex(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves information about a SynonymMap.
+     * @param synonymMapName - The name of the SynonymMap.
+     * @param options - Additional optional arguments.
+     */
+    async getSynonymMap(synonymMapName, 
+    // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+    options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getSynonymMaps", options);
+        try {
+            const result = await this.client.synonymMaps.get(synonymMapName, updatedOptions);
+            return utils.generatedSynonymMapToPublicSynonymMap(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new index.
+     * @param index - The information describing the index to be created.
+     * @param options - Additional optional arguments.
+     */
+    async createIndex(index, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createIndex", options);
+        try {
+            const result = await this.client.indexes.create(utils.publicIndexToGeneratedIndex(index), updatedOptions);
+            return utils.generatedIndexToPublicIndex(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new SynonymMap in a search service.
+     * @param synonymMap - The synonymMap definition to create in a search service.
+     * @param options - Additional optional arguments.
+     */
+    async createSynonymMap(synonymMap, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createSynonymMaps", options);
+        try {
+            const result = await this.client.synonymMaps.create(utils.publicSynonymMapToGeneratedSynonymMap(synonymMap), updatedOptions);
+            return utils.generatedSynonymMapToPublicSynonymMap(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new index or modifies an existing one.
+     * @param index - The information describing the index to be created.
+     * @param options - Additional optional arguments.
+     */
+    async createOrUpdateIndex(index, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createOrUpdateIndex", options);
+        try {
+            const etag = options.onlyIfUnchanged ? index.etag : undefined;
+            const result = await this.client.indexes.createOrUpdate(index.name, utils.publicIndexToGeneratedIndex(index), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return utils.generatedIndexToPublicIndex(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new SynonymMap or modifies an existing one.
+     * @param synonymMap - The information describing the SynonymMap to be created.
+     * @param options - Additional optional arguments.
+     */
+    async createOrUpdateSynonymMap(synonymMap, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createOrUpdateSynonymMap", options);
+        try {
+            const etag = options.onlyIfUnchanged ? synonymMap.etag : undefined;
+            const result = await this.client.synonymMaps.createOrUpdate(synonymMap.name, utils.publicSynonymMapToGeneratedSynonymMap(synonymMap), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return utils.generatedSynonymMapToPublicSynonymMap(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async deleteIndex(index, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-deleteIndex", options);
+        try {
+            const indexName = typeof index === "string" ? index : index.name;
+            const etag = typeof index === "string" ? undefined : options.onlyIfUnchanged ? index.etag : undefined;
+            await this.client.indexes.delete(indexName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Deletes an existing SynonymMap.
+     * @param synonymMapName - SynonymMap/Name of the synonymMap to delete.
+     * @param options - Additional optional arguments.
+     */
+    async deleteSynonymMap(synonymMap, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-deleteSynonymMap", options);
+        try {
+            const synonymMapName = typeof synonymMap === "string" ? synonymMap : synonymMap.name;
+            const etag = typeof synonymMap === "string"
+                ? undefined
+                : options.onlyIfUnchanged
+                    ? synonymMap.etag
+                    : undefined;
+            await this.client.synonymMaps.delete(synonymMapName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new search alias or updates an alias if it already exists.
+     * @param alias - The definition of the alias to create or update.
+     * @param options - The options parameters.
+     */
+    async createOrUpdateAlias(alias, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createOrUpdateAlias", options);
+        try {
+            const etag = options.onlyIfUnchanged ? alias.etag : undefined;
+            const result = await this.client.aliases.createOrUpdate(alias.name, alias, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new search alias.
+     * @param alias - The definition of the alias to create.
+     * @param options - The options parameters.
+     */
+    async createAlias(alias, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createAlias", options);
+        try {
+            const result = await this.client.aliases.create(alias, updatedOptions);
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async deleteAlias(alias, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-deleteAlias", options);
+        try {
+            const aliasName = typeof alias === "string" ? alias : alias.name;
+            const etag = typeof alias === "string" ? undefined : options.onlyIfUnchanged ? alias.etag : undefined;
+            await this.client.aliases.delete(aliasName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves an alias definition.
+     * @param aliasName - The name of the alias to retrieve.
+     * @param options - The options parameters.
+     */
+    async getAlias(aliasName, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getAlias", options);
+        try {
+            const result = await this.client.aliases.get(aliasName, updatedOptions);
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves statistics about an index, such as the count of documents and the size
+     * of index storage.
+     * @param indexName - The name of the index.
+     * @param options - Additional optional arguments.
+     */
+    async getIndexStatistics(indexName, options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getIndexStatistics", options);
+        try {
+            const result = await this.client.indexes.getStatistics(indexName, updatedOptions);
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Calls an analyzer or tokenizer manually on provided text.
+     * @param indexName - The name of the index that contains the field to analyze
+     * @param text - The text to break into tokens.
+     * @param options - Additional arguments
+     */
+    async analyzeText(indexName, options) {
+        const { abortSignal, requestOptions, tracingOptions, analyzerName: analyzer, tokenizerName: tokenizer, ...restOptions } = options;
+        const operationOptions = {
+            abortSignal,
+            requestOptions,
+            tracingOptions,
+        };
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-analyzeText", operationOptions);
+        try {
+            const result = await this.client.indexes.analyze(indexName, { ...restOptions, analyzer, tokenizer }, updatedOptions);
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves statistics about the service, such as the count of documents, index, etc.
+     * @param options - Additional optional arguments.
+     */
+    async getServiceStatistics(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getServiceStatistics", options);
+        try {
+            const result = await this.client.getServiceStatistics(updatedOptions);
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *getIndexStatsSummaryPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getIndexStatsSummaryPage", options);
+        try {
+            const { indexesStatistics } = await this.client.getIndexStatsSummary(updatedOptions);
+            yield indexesStatistics;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *getIndexStatsSummaryAll(options = {}) {
+        for await (const page of this.getIndexStatsSummaryPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Retrieves a list of existing indexes in the service.
+     * @param options - Options to the list index operation.
+     */
+    getIndexStatsSummary(options = {}) {
+        const iter = this.getIndexStatsSummaryAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.getIndexStatsSummaryPage(options);
+            },
+        };
+    }
+    /**
+     * Creates a new agent.
+     * @param knowledgeAgent - definition of the agent to create.
+     * @param options - options parameters.
+     */
+    async createKnowledgeAgent(knowledgeAgent, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createKnowledgeAgent", options);
+        try {
+            const result = await this.client.knowledgeAgents.create(utils.convertKnowledgeAgentToGenerated(knowledgeAgent), updatedOptions);
+            return utils.convertKnowledgeAgentToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Creates a new agent or updates an agent if it already exists.
+     * @param agentName - name of the agent to create or update.
+     * @param knowledgeAgent - definition of the agent to create or update.
+     * @param options - options parameters.
+     */
+    async createOrUpdateKnowledgeAgent(agentName, knowledgeAgent, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createOrUpdateKnowledgeAgent", options);
+        try {
+            const etag = updatedOptions.onlyIfUnchanged ? knowledgeAgent.etag : undefined;
+            const result = await this.client.knowledgeAgents.createOrUpdate(agentName, utils.convertKnowledgeAgentToGenerated(knowledgeAgent), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return utils.convertKnowledgeAgentToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves an agent definition.
+     * @param agentName - name of the agent to retrieve.
+     * @param options - options parameters.
+     */
+    async getKnowledgeAgent(agentName, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getKnowledgeAgent", options);
+        try {
+            const result = await this.client.knowledgeAgents.get(agentName, updatedOptions);
+            return utils.convertKnowledgeAgentToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listKnowledgeAgentsPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listKnowledgeAgentsPage", options);
+        try {
+            const { knowledgeAgents } = await this.client.knowledgeAgents.list(updatedOptions);
+            const mapped = knowledgeAgents.map((agent) => utils.convertKnowledgeAgentToPublic(agent));
+            yield mapped;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listKnowledgeAgentsAll(options = {}) {
+        for await (const page of this.listKnowledgeAgentsPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Retrieves a list of existing KnowledgeAgents in the service.
+     * @param options - Options to the list knowledge agents operation.
+     */
+    listKnowledgeAgents(options = {}) {
+        const iter = this.listKnowledgeAgentsAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.listKnowledgeAgentsPage(options);
+            },
+        };
+    }
+    async deleteKnowledgeAgent(agent, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-deleteKnowledgeAgent", options);
+        try {
+            const agentName = typeof agent === "string" ? agent : agent.name;
+            const etag = typeof agent !== "string" && updatedOptions.onlyIfUnchanged ? agent.etag : undefined;
+            const result = await this.client.knowledgeAgents.delete(agentName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async createOrUpdateKnowledgeSource(sourceName, knowledgeSource, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createOrUpdateKnowledgeSource", options);
+        try {
+            const etag = updatedOptions.onlyIfUnchanged ? knowledgeSource.etag : undefined;
+            const result = await this.client.knowledgeSources.createOrUpdate(sourceName, utils.convertKnowledgeSourceToGenerated(knowledgeSource), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return utils.convertKnowledgeSourceToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async deleteKnowledgeSource(source, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-deleteKnowledgeSource", options);
+        try {
+            const sourceName = typeof source === "string" ? source : source.name;
+            const etag = typeof source !== "string" && updatedOptions.onlyIfUnchanged ? source.etag : undefined;
+            const result = await this.client.knowledgeSources.delete(sourceName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
+            return result;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves a knowledge source definition.
+     * @param sourceName - The name of the knowledge source to retrieve.
+     * @param options - The options parameters.
+     */
+    async getKnowledgeSource(sourceName, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-getKnowledgeSource", options);
+        try {
+            const result = await this.client.knowledgeSources.get(sourceName, updatedOptions);
+            return utils.convertKnowledgeSourceToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listKnowledgeSourcesPage(options = {}) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-listKnowledgeSourcesPage", options);
+        try {
+            const { knowledgeSources } = await this.client.knowledgeSources.list(updatedOptions);
+            const mapped = knowledgeSources.map((source) => utils.convertKnowledgeSourceToPublic(source));
+            yield mapped;
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async *listKnowledgeSourcesAll(options = {}) {
+        for await (const page of this.listKnowledgeSourcesPage(options)) {
+            yield* page;
+        }
+    }
+    /**
+     * Retrieves a list of existing KnowledgeSources in the service.
+     * @param options - Options to the list knowledge sources operation.
+     */
+    listKnowledgeSources(options = {}) {
+        const iter = this.listKnowledgeSourcesAll(options);
+        return {
+            next() {
+                return iter.next();
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            byPage: () => {
+                return this.listKnowledgeSourcesPage(options);
+            },
+        };
+    }
+    /**
+     * Creates a new knowledge source.
+     * @param knowledgeSource - The definition of the knowledge source to create.
+     * @param options - The options parameters.
+     */
+    async createKnowledgeSource(knowledgeSource, options) {
+        const { span, updatedOptions } = (0, tracing_js_1.createSpan)("SearchIndexClient-createKnowledgeSource", options);
+        try {
+            const result = await this.client.knowledgeSources.create(utils.convertKnowledgeSourceToGenerated(knowledgeSource), updatedOptions);
+            return utils.convertKnowledgeSourceToPublic(result);
+        }
+        catch (e) {
+            span.setStatus({
+                status: "error",
+                error: e.message,
+            });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    }
+    /**
+     * Retrieves the SearchClient corresponding to this SearchIndexClient
+     * @param indexName - Name of the index
+     * @param options - SearchClient Options
+     * @typeParam TModel - An optional type that represents the documents stored in the search index.
+     * For the best typing experience, all non-key fields should be marked optional and nullable, and
+     * the key property should have the non-nullable type `string`.
+     */
+    getSearchClient(indexName, options) {
+        return new searchClient_js_1.SearchClient(this.endpoint, indexName, this.credential, options || this.options);
+    }
+    /**
+     * Retrieves the KnowledgeRetrievalClient corresponding to this SearchIndexClient
+     * @param agentName - Name of the agent
+     * @param options - KnowledgeRetrievalClient Options
+     */
+    getKnowledgeRetrievalClient(agentName, options) {
+        return new knowledgeRetrievalClient_js_1.KnowledgeRetrievalClient(this.endpoint, agentName, this.credential, options || this.options);
+    }
+}
+exports.SearchIndexClient = SearchIndexClient;
+//# sourceMappingURL=searchIndexClient.js.map