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

package/{dist-esm/src → dist/browser}/searchIndexClient.js

@@ -1,68 +1,87 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { __asyncDelegator, __asyncGenerator, __asyncValues, __await, __rest } from "tslib";
-/// <reference lib="esnext.asynciterable" />
 import { isTokenCredential } from "@azure/core-auth";
 import { bearerTokenAuthenticationPolicy } from "@azure/core-rest-pipeline";
-import { SearchServiceClient as GeneratedClient } from "./generated/service/searchServiceClient";
-import { logger } from "./logger";
-import { createOdataMetadataPolicy } from "./odataMetadataPolicy";
-import { createSearchApiKeyCredentialPolicy } from "./searchApiKeyCredentialPolicy";
-import { KnownSearchAudience } from "./searchAudience";
-import { SearchClient } from "./searchClient";
-import * as utils from "./serviceUtils";
-import { createSpan } from "./tracing";
+import { SearchServiceClient as GeneratedClient } from "./generated/service/searchServiceClient.js";
+import { KnowledgeRetrievalClient } from "./knowledgeRetrievalClient.js";
+import { logger } from "./logger.js";
+import { createOdataMetadataPolicy } from "./odataMetadataPolicy.js";
+import { createSearchApiKeyCredentialPolicy } from "./searchApiKeyCredentialPolicy.js";
+import { KnownSearchAudience } from "./searchAudience.js";
+import { SearchClient } from "./searchClient.js";
+import * as utils from "./serviceUtils.js";
+import { createSpan } from "./tracing.js";
 /**
  * Class to perform operations to manage
  * (create, update, list/delete)
  * indexes, & synonymmaps.
  */
 export 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
-     * const { SearchIndexClient, AzureKeyCredential } = require("@azure/search-documents");
+     * ```ts snippet:ReadmeSampleSearchIndexClient
+     * import { SearchIndexClient, AzureKeyCredential } from "@azure/search-documents";
      *
-     * const client = new SearchIndexClient(
-     *   "<endpoint>",
-     *   new AzureKeyCredential("<Admin Key>");
-     * );
+     * 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 = {}) {
-        var _a, _b;
-        /**
-         * The API version to use when communicating with the service.
-         */
-        this.serviceVersion = utils.defaultServiceVersion;
-        /**
-         * The API version to use when communicating with the service.
-         * @deprecated use {@Link serviceVersion} instead
-         */
-        this.apiVersion = utils.defaultServiceVersion;
         this.endpoint = endpoint;
         this.credential = credential;
         this.options = options;
-        const internalClientPipelineOptions = Object.assign(Object.assign({}, this.options), {
-            loggingOptions: {
-                logger: logger.info,
-                additionalAllowedHeaderNames: [
-                    "elapsed-time",
-                    "Location",
-                    "OData-MaxVersion",
-                    "OData-Version",
-                    "Prefer",
-                    "throttle-reason",
-                ],
+        const internalClientPipelineOptions = {
+            ...this.options,
+            ...{
+                loggingOptions: {
+                    logger: logger.info,
+                    additionalAllowedHeaderNames: [
+                        "elapsed-time",
+                        "Location",
+                        "OData-MaxVersion",
+                        "OData-Version",
+                        "Prefer",
+                        "throttle-reason",
+                    ],
+                },
             },
-        });
+        };
         this.serviceVersion =
-            (_b = (_a = this.options.serviceVersion) !== null && _a !== void 0 ? _a : this.options.apiVersion) !== null && _b !== void 0 ? _b : utils.defaultServiceVersion;
+            this.options.serviceVersion ?? this.options.apiVersion ?? utils.defaultServiceVersion;
         this.apiVersion = this.serviceVersion;
         this.client = new GeneratedClient(this.endpoint, this.serviceVersion, internalClientPipelineOptions);
         this.pipeline = this.client.pipeline;
@@ -77,45 +96,28 @@ export class SearchIndexClient {
         }
         this.client.pipeline.addPolicy(createOdataMetadataPolicy("minimal"));
     }
-    listIndexesPage(options = {}) {
-        return __asyncGenerator(this, arguments, function* listIndexesPage_1() {
-            const { span, updatedOptions } = createSpan("SearchIndexClient-listIndexesPage", options);
-            try {
-                const result = yield __await(this.client.indexes.list(updatedOptions));
-                const mapped = result.indexes.map(utils.generatedIndexToPublicIndex);
-                yield yield __await(mapped);
-            }
-            catch (e) {
-                span.setStatus({
-                    status: "error",
-                    error: e.message,
-                });
-                throw e;
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    listIndexesAll(options = {}) {
-        return __asyncGenerator(this, arguments, function* listIndexesAll_1() {
-            var _a, e_1, _b, _c;
-            try {
-                for (var _d = true, _e = __asyncValues(this.listIndexesPage(options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const page = _c;
-                    yield __await(yield* __asyncDelegator(__asyncValues(page)));
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        });
+    async *listIndexesPage(options = {}) {
+        const { span, updatedOptions } = 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.
@@ -135,44 +137,27 @@ export class SearchIndexClient {
             },
         };
     }
-    listAliasesPage(options = {}) {
-        return __asyncGenerator(this, arguments, function* listAliasesPage_1() {
-            const { span, updatedOptions } = createSpan("SearchIndexClient-listAliases", options);
-            try {
-                const result = yield __await(this.client.aliases.list(updatedOptions));
-                yield yield __await(result.aliases);
-            }
-            catch (e) {
-                span.setStatus({
-                    status: "error",
-                    error: e.message,
-                });
-                throw e;
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    listAliasesAll(options = {}) {
-        return __asyncGenerator(this, arguments, function* listAliasesAll_1() {
-            var _a, e_2, _b, _c;
-            try {
-                for (var _d = true, _e = __asyncValues(this.listAliasesPage(options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const page = _c;
-                    yield __await(yield* __asyncDelegator(__asyncValues(page)));
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        });
+    async *listAliasesPage(options = {}) {
+        const { span, updatedOptions } = 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.
@@ -192,50 +177,37 @@ export class SearchIndexClient {
             },
         };
     }
-    listIndexesNamesPage(options = {}) {
-        return __asyncGenerator(this, arguments, function* listIndexesNamesPage_1() {
-            const { span, updatedOptions } = createSpan("SearchIndexClient-listIndexesNamesPage", options);
-            try {
-                const result = yield __await(this.client.indexes.list(Object.assign(Object.assign({}, updatedOptions), { select: "name" })));
-                const mapped = result.indexes.map((idx) => idx.name);
-                yield yield __await(mapped);
-            }
-            catch (e) {
-                span.setStatus({
-                    status: "error",
-                    error: e.message,
-                });
-                throw e;
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    listIndexesNamesAll(options = {}) {
-        return __asyncGenerator(this, arguments, function* listIndexesNamesAll_1() {
-            var _a, e_3, _b, _c;
-            try {
-                for (var _d = true, _e = __asyncValues(this.listIndexesNamesPage(options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const page = _c;
-                    yield __await(yield* __asyncDelegator(__asyncValues(page)));
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-        });
+    async *listIndexesNamesPage(options = {}) {
+        const { span, updatedOptions } = 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 {
@@ -275,10 +247,14 @@ export class SearchIndexClient {
      * 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 } = createSpan("SearchIndexClient-listSynonymMapsNames", options);
         try {
-            const result = await this.client.synonymMaps.list(Object.assign(Object.assign({}, updatedOptions), { select: "name" }));
+            const result = await this.client.synonymMaps.list({
+                ...updatedOptions,
+                select: "name",
+            });
             return result.synonymMaps.map((sm) => sm.name);
         }
         catch (e) {
@@ -319,7 +295,9 @@ export class SearchIndexClient {
      * @param synonymMapName - The name of the SynonymMap.
      * @param options - Additional optional arguments.
      */
-    async getSynonymMap(synonymMapName, options = {}) {
+    async getSynonymMap(synonymMapName, 
+    // eslint-disable-next-line @azure/azure-sdk/ts-naming-options
+    options = {}) {
         const { span, updatedOptions } = createSpan("SearchIndexClient-getSynonymMaps", options);
         try {
             const result = await this.client.synonymMaps.get(synonymMapName, updatedOptions);
@@ -389,7 +367,10 @@ export class SearchIndexClient {
         const { span, updatedOptions } = createSpan("SearchIndexClient-createOrUpdateIndex", options);
         try {
             const etag = options.onlyIfUnchanged ? index.etag : undefined;
-            const result = await this.client.indexes.createOrUpdate(index.name, utils.publicIndexToGeneratedIndex(index), Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            const result = await this.client.indexes.createOrUpdate(index.name, utils.publicIndexToGeneratedIndex(index), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
             return utils.generatedIndexToPublicIndex(result);
         }
         catch (e) {
@@ -412,7 +393,10 @@ export class SearchIndexClient {
         const { span, updatedOptions } = createSpan("SearchIndexClient-createOrUpdateSynonymMap", options);
         try {
             const etag = options.onlyIfUnchanged ? synonymMap.etag : undefined;
-            const result = await this.client.synonymMaps.createOrUpdate(synonymMap.name, utils.publicSynonymMapToGeneratedSynonymMap(synonymMap), Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            const result = await this.client.synonymMaps.createOrUpdate(synonymMap.name, utils.publicSynonymMapToGeneratedSynonymMap(synonymMap), {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
             return utils.generatedSynonymMapToPublicSynonymMap(result);
         }
         catch (e) {
@@ -426,17 +410,15 @@ export class SearchIndexClient {
             span.end();
         }
     }
-    /**
-     * Deletes an existing index.
-     * @param indexName - Index/Name of the index to delete.
-     * @param options - Additional optional arguments.
-     */
     async deleteIndex(index, options = {}) {
         const { span, updatedOptions } = 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, Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            await this.client.indexes.delete(indexName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
         }
         catch (e) {
             span.setStatus({
@@ -463,7 +445,10 @@ export class SearchIndexClient {
                 : options.onlyIfUnchanged
                     ? synonymMap.etag
                     : undefined;
-            await this.client.synonymMaps.delete(synonymMapName, Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            await this.client.synonymMaps.delete(synonymMapName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
         }
         catch (e) {
             span.setStatus({
@@ -485,7 +470,10 @@ export class SearchIndexClient {
         const { span, updatedOptions } = createSpan("SearchIndexClient-createOrUpdateAlias", options);
         try {
             const etag = options.onlyIfUnchanged ? alias.etag : undefined;
-            const result = await this.client.aliases.createOrUpdate(alias.name, alias, Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            const result = await this.client.aliases.createOrUpdate(alias.name, alias, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
             return result;
         }
         catch (e) {
@@ -521,18 +509,15 @@ export class SearchIndexClient {
             span.end();
         }
     }
-    /**
-     * 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.
-     * @param alias - Alias/Name name of the alias to delete.
-     * @param options - The options parameters.
-     */
     async deleteAlias(alias, options = {}) {
         const { span, updatedOptions } = 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, Object.assign(Object.assign({}, updatedOptions), { ifMatch: etag }));
+            await this.client.aliases.delete(aliasName, {
+                ...updatedOptions,
+                ifMatch: etag,
+            });
         }
         catch (e) {
             span.setStatus({
@@ -597,7 +582,7 @@ export class SearchIndexClient {
      * @param options - Additional arguments
      */
     async analyzeText(indexName, options) {
-        const { abortSignal, requestOptions, tracingOptions, analyzerName: analyzer, tokenizerName: tokenizer } = options, restOptions = __rest(options, ["abortSignal", "requestOptions", "tracingOptions", "analyzerName", "tokenizerName"]);
+        const { abortSignal, requestOptions, tracingOptions, analyzerName: analyzer, tokenizerName: tokenizer, ...restOptions } = options;
         const operationOptions = {
             abortSignal,
             requestOptions,
@@ -605,7 +590,7 @@ export class SearchIndexClient {
         };
         const { span, updatedOptions } = createSpan("SearchIndexClient-analyzeText", operationOptions);
         try {
-            const result = await this.client.indexes.analyze(indexName, Object.assign(Object.assign({}, restOptions), { analyzer, tokenizer }), updatedOptions);
+            const result = await this.client.indexes.analyze(indexName, { ...restOptions, analyzer, tokenizer }, updatedOptions);
             return result;
         }
         catch (e) {
@@ -640,17 +625,326 @@ export class SearchIndexClient {
             span.end();
         }
     }
+    async *getIndexStatsSummaryPage(options = {}) {
+        const { span, updatedOptions } = 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 } = 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 } = 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 } = 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 } = 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 } = 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 } = 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 } = 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 } = 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 } = 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 } = 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`.
+     * @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(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(this.endpoint, agentName, this.credential, options || this.options);
+    }
 }
 //# sourceMappingURL=searchIndexClient.js.map