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

package/dist/commonjs/serviceUtils.js

@@ -1,810 +1,912 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultServiceVersion = void 0;
-exports.convertSkillsToPublic = convertSkillsToPublic;
-exports.convertCognitiveServicesAccountToGenerated = convertCognitiveServicesAccountToGenerated;
-exports.convertCognitiveServicesAccountToPublic = convertCognitiveServicesAccountToPublic;
-exports.convertTokenFiltersToGenerated = convertTokenFiltersToGenerated;
-exports.convertFieldsToPublic = convertFieldsToPublic;
-exports.convertFieldsToGenerated = convertFieldsToGenerated;
-exports.convertSimilarityToGenerated = convertSimilarityToGenerated;
-exports.convertSimilarityToPublic = convertSimilarityToPublic;
-exports.generatedIndexToPublicIndex = generatedIndexToPublicIndex;
-exports.generatedVectorSearchVectorizerToPublicVectorizer = generatedVectorSearchVectorizerToPublicVectorizer;
-exports.generatedKnowledgeSourceVectorizerToPublicVectorizer = generatedKnowledgeSourceVectorizerToPublicVectorizer;
-exports.generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration = generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration;
-exports.generatedVectorSearchToPublicVectorSearch = generatedVectorSearchToPublicVectorSearch;
-exports.generatedSearchResultToPublicSearchResult = generatedSearchResultToPublicSearchResult;
-exports.generatedSuggestDocumentsResultToPublicSuggestDocumentsResult = generatedSuggestDocumentsResultToPublicSuggestDocumentsResult;
-exports.publicIndexToGeneratedIndex = publicIndexToGeneratedIndex;
-exports.generatedSkillsetToPublicSkillset = generatedSkillsetToPublicSkillset;
-exports.publicSkillsetToGeneratedSkillset = publicSkillsetToGeneratedSkillset;
-exports.generatedSynonymMapToPublicSynonymMap = generatedSynonymMapToPublicSynonymMap;
-exports.publicSynonymMapToGeneratedSynonymMap = publicSynonymMapToGeneratedSynonymMap;
-exports.publicSearchIndexerToGeneratedSearchIndexer = publicSearchIndexerToGeneratedSearchIndexer;
-exports.generatedSearchIndexerToPublicSearchIndexer = generatedSearchIndexerToPublicSearchIndexer;
-exports.publicDataSourceToGeneratedDataSource = publicDataSourceToGeneratedDataSource;
-exports.generatedDataSourceToPublicDataSource = generatedDataSourceToPublicDataSource;
-exports.convertSearchIndexerDataIdentityToPublic = convertSearchIndexerDataIdentityToPublic;
-exports.convertDataChangeDetectionPolicyToPublic = convertDataChangeDetectionPolicyToPublic;
-exports.convertDataDeletionDetectionPolicyToPublic = convertDataDeletionDetectionPolicyToPublic;
-exports.getRandomIntegerInclusive = getRandomIntegerInclusive;
-exports.convertSearchIndexerCacheToPublic = convertSearchIndexerCacheToPublic;
-exports.convertKnowledgeBaseToPublic = convertKnowledgeBaseToPublic;
-exports.convertKnowledgeBaseToGenerated = convertKnowledgeBaseToGenerated;
-exports.convertKnowledgeSourceToPublic = convertKnowledgeSourceToPublic;
-exports.convertKnowledgeSourceToGenerated = convertKnowledgeSourceToGenerated;
-const logger_js_1 = require("./logger.js");
-const serviceModels_js_1 = require("./serviceModels.js");
-exports.defaultServiceVersion = "2025-11-01-Preview";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serviceUtils_exports = {};
+__export(serviceUtils_exports, {
+  convertCognitiveServicesAccountToGenerated: () => convertCognitiveServicesAccountToGenerated,
+  convertCognitiveServicesAccountToPublic: () => convertCognitiveServicesAccountToPublic,
+  convertDataChangeDetectionPolicyToPublic: () => convertDataChangeDetectionPolicyToPublic,
+  convertDataDeletionDetectionPolicyToPublic: () => convertDataDeletionDetectionPolicyToPublic,
+  convertFieldsToGenerated: () => convertFieldsToGenerated,
+  convertFieldsToPublic: () => convertFieldsToPublic,
+  convertGeneratedAnswersToPublic: () => convertGeneratedAnswersToPublic,
+  convertGeneratedCaptionsToPublic: () => convertGeneratedCaptionsToPublic,
+  convertGeneratedFacetResultToPublic: () => convertGeneratedFacetResultToPublic,
+  convertGeneratedFacetsToPublic: () => convertGeneratedFacetsToPublic,
+  convertGeneratedQueryAnswerResultToPublic: () => convertGeneratedQueryAnswerResultToPublic,
+  convertGeneratedQueryCaptionResultToPublic: () => convertGeneratedQueryCaptionResultToPublic,
+  convertKnowledgeBaseToGenerated: () => convertKnowledgeBaseToGenerated,
+  convertKnowledgeBaseToPublic: () => convertKnowledgeBaseToPublic,
+  convertKnowledgeSourceToGenerated: () => convertKnowledgeSourceToGenerated,
+  convertKnowledgeSourceToPublic: () => convertKnowledgeSourceToPublic,
+  convertPublicActionsToGeneratedActions: () => convertPublicActionsToGeneratedActions,
+  convertSearchIndexerDataIdentityToPublic: () => convertSearchIndexerDataIdentityToPublic,
+  convertSimilarityToGenerated: () => convertSimilarityToGenerated,
+  convertSimilarityToPublic: () => convertSimilarityToPublic,
+  convertSkillsToPublic: () => convertSkillsToPublic,
+  convertTokenFiltersToGenerated: () => convertTokenFiltersToGenerated,
+  defaultServiceVersion: () => defaultServiceVersion,
+  generatedDataSourceToPublicDataSource: () => generatedDataSourceToPublicDataSource,
+  generatedIndexToPublicIndex: () => generatedIndexToPublicIndex,
+  generatedKnowledgeSourceVectorizerToPublicVectorizer: () => generatedKnowledgeSourceVectorizerToPublicVectorizer,
+  generatedSearchIndexerToPublicSearchIndexer: () => generatedSearchIndexerToPublicSearchIndexer,
+  generatedSearchResultToPublicSearchResult: () => generatedSearchResultToPublicSearchResult,
+  generatedSkillsetToPublicSkillset: () => generatedSkillsetToPublicSkillset,
+  generatedSuggestDocumentsResultToPublicSuggestDocumentsResult: () => generatedSuggestDocumentsResultToPublicSuggestDocumentsResult,
+  generatedSynonymMapToPublicSynonymMap: () => generatedSynonymMapToPublicSynonymMap,
+  generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration: () => generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration,
+  generatedVectorSearchToPublicVectorSearch: () => generatedVectorSearchToPublicVectorSearch,
+  generatedVectorSearchVectorizerToPublicVectorizer: () => generatedVectorSearchVectorizerToPublicVectorizer,
+  mapPagedAsyncIterable: () => mapPagedAsyncIterable,
+  publicDataSourceToGeneratedDataSource: () => publicDataSourceToGeneratedDataSource,
+  publicIndexToGeneratedIndex: () => publicIndexToGeneratedIndex,
+  publicSearchIndexerToGeneratedSearchIndexer: () => publicSearchIndexerToGeneratedSearchIndexer,
+  publicSkillsetToGeneratedSkillset: () => publicSkillsetToGeneratedSkillset,
+  publicSynonymMapToGeneratedSynonymMap: () => publicSynonymMapToGeneratedSynonymMap
+});
+module.exports = __toCommonJS(serviceUtils_exports);
+var import_logger = require("./logger.js");
+var import_serviceModels = require("./serviceModels.js");
+const defaultServiceVersion = "2026-04-01";
 const knownSkills = {
-    "#Microsoft.Skills.Custom.ChatCompletionSkill": true,
-    "#Microsoft.Skills.Custom.WebApiSkill": true,
-    "#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill": true,
-    "#Microsoft.Skills.Text.CustomEntityLookupSkill": true,
-    "#Microsoft.Skills.Text.EntityRecognitionSkill": true,
-    "#Microsoft.Skills.Text.KeyPhraseExtractionSkill": true,
-    "#Microsoft.Skills.Text.LanguageDetectionSkill": true,
-    "#Microsoft.Skills.Text.MergeSkill": true,
-    "#Microsoft.Skills.Text.PIIDetectionSkill": true,
-    "#Microsoft.Skills.Text.SentimentSkill": true,
-    "#Microsoft.Skills.Text.SplitSkill": true,
-    "#Microsoft.Skills.Text.TranslationSkill": true,
-    "#Microsoft.Skills.Text.V3.EntityLinkingSkill": true,
-    "#Microsoft.Skills.Text.V3.EntityRecognitionSkill": true,
-    "#Microsoft.Skills.Text.V3.SentimentSkill": true,
-    "#Microsoft.Skills.Util.ConditionalSkill": true,
-    "#Microsoft.Skills.Util.DocumentExtractionSkill": true,
-    "#Microsoft.Skills.Util.ShaperSkill": true,
-    "#Microsoft.Skills.Vision.ImageAnalysisSkill": true,
-    "#Microsoft.Skills.Vision.OcrSkill": true,
-    "#Microsoft.Skills.Custom.AmlSkill": true,
-    "#Microsoft.Skills.Vision.VectorizeSkill": true,
-    "#Microsoft.Skills.Util.DocumentIntelligenceLayoutSkill": true,
-    "#Microsoft.Skills.Util.ContentUnderstandingSkill": true,
+  "#Microsoft.Skills.Custom.ChatCompletionSkill": true,
+  "#Microsoft.Skills.Custom.WebApiSkill": true,
+  "#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill": true,
+  "#Microsoft.Skills.Text.CustomEntityLookupSkill": true,
+  "#Microsoft.Skills.Text.EntityRecognitionSkill": true,
+  "#Microsoft.Skills.Text.KeyPhraseExtractionSkill": true,
+  "#Microsoft.Skills.Text.LanguageDetectionSkill": true,
+  "#Microsoft.Skills.Text.MergeSkill": true,
+  "#Microsoft.Skills.Text.PIIDetectionSkill": true,
+  "#Microsoft.Skills.Text.SentimentSkill": true,
+  "#Microsoft.Skills.Text.SplitSkill": true,
+  "#Microsoft.Skills.Text.TranslationSkill": true,
+  "#Microsoft.Skills.Text.V3.EntityLinkingSkill": true,
+  "#Microsoft.Skills.Text.V3.EntityRecognitionSkill": true,
+  "#Microsoft.Skills.Text.V3.SentimentSkill": true,
+  "#Microsoft.Skills.Util.ConditionalSkill": true,
+  "#Microsoft.Skills.Util.DocumentExtractionSkill": true,
+  "#Microsoft.Skills.Util.ShaperSkill": true,
+  "#Microsoft.Skills.Vision.ImageAnalysisSkill": true,
+  "#Microsoft.Skills.Vision.OcrSkill": true,
+  "#Microsoft.Skills.Custom.AmlSkill": true,
+  "#Microsoft.Skills.Vision.VectorizeSkill": true,
+  "#Microsoft.Skills.Util.DocumentIntelligenceLayoutSkill": true,
+  "#Microsoft.Skills.Util.ContentUnderstandingSkill": true
 };
 function convertSkillsToPublic(skills) {
-    if (!skills) {
-        return skills;
-    }
-    // This validation has already GAed
-    return skills.filter((skill) => knownSkills[skill.odatatype]);
+  if (!skills) {
+    return [];
+  }
+  return skills.filter((skill) => knownSkills[skill.odatatype]);
 }
 function convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount) {
-    if (!cognitiveServicesAccount) {
-        return cognitiveServicesAccount;
-    }
-    switch (cognitiveServicesAccount.odatatype) {
-        case "#Microsoft.Azure.Search.AIServicesByIdentity":
-        case "#Microsoft.Azure.Search.DefaultCognitiveServices":
-        case "#Microsoft.Azure.Search.CognitiveServicesByKey":
-        case "#Microsoft.Azure.Search.AIServicesByKey":
-            return cognitiveServicesAccount;
-        default: {
-            logger_js_1.logger.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
-            return cognitiveServicesAccount;
-        }
-    }
+  if (!cognitiveServicesAccount) {
+    return cognitiveServicesAccount;
+  }
+  switch (cognitiveServicesAccount.odatatype) {
+    case "#Microsoft.Azure.Search.AIServicesByIdentity":
+    case "#Microsoft.Azure.Search.DefaultCognitiveServices":
+    case "#Microsoft.Azure.Search.CognitiveServicesByKey":
+    case "#Microsoft.Azure.Search.AIServicesByKey":
+      return cognitiveServicesAccount;
+    default: {
+      import_logger.logger.warning(
+        `Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`
+      );
+      return cognitiveServicesAccount;
+    }
+  }
 }
 function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount) {
-    if (!cognitiveServicesAccount) {
-        return cognitiveServicesAccount;
-    }
-    const deserializers = {
-        "#Microsoft.Azure.Search.DefaultCognitiveServices": () => {
-            return cognitiveServicesAccount;
-        },
-        "#Microsoft.Azure.Search.CognitiveServicesByKey": () => {
-            return cognitiveServicesAccount;
-        },
-        "#Microsoft.Azure.Search.AIServicesByKey": () => {
-            return cognitiveServicesAccount;
-        },
-        "#Microsoft.Azure.Search.AIServicesByIdentity": () => {
-            const { identity, ...restParams } = cognitiveServicesAccount;
-            return {
-                ...restParams,
-                identity: convertSearchIndexerDataIdentityToPublic(identity ?? undefined),
-            };
-        },
-    };
-    const defaultDeserializer = () => {
-        logger_js_1.logger.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
-        return cognitiveServicesAccount;
-    };
-    return (deserializers[cognitiveServicesAccount.odatatype] ?? defaultDeserializer)();
+  if (!cognitiveServicesAccount) {
+    return void 0;
+  }
+  const deserializers = {
+    "#Microsoft.Azure.Search.DefaultCognitiveServices": () => {
+      return cognitiveServicesAccount;
+    },
+    "#Microsoft.Azure.Search.CognitiveServicesByKey": () => {
+      return cognitiveServicesAccount;
+    },
+    "#Microsoft.Azure.Search.AIServicesByKey": () => {
+      return cognitiveServicesAccount;
+    },
+    "#Microsoft.Azure.Search.AIServicesByIdentity": () => {
+      const { identity, ...restParams } = cognitiveServicesAccount;
+      return {
+        ...restParams,
+        identity: convertSearchIndexerDataIdentityToPublic(identity)
+      };
+    }
+  };
+  const defaultDeserializer = () => {
+    import_logger.logger.warning(
+      `Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`
+    );
+    return cognitiveServicesAccount;
+  };
+  return (deserializers[cognitiveServicesAccount.odatatype] ?? defaultDeserializer)();
 }
 function convertTokenFiltersToGenerated(tokenFilters) {
-    if (!tokenFilters) {
-        return tokenFilters;
-    }
-    const result = [];
-    for (const filter of tokenFilters) {
-        result.push(filter);
-    }
-    return result;
+  if (!tokenFilters) {
+    return tokenFilters;
+  }
+  const result = [];
+  for (const filter of tokenFilters) {
+    result.push(filter);
+  }
+  return result;
 }
 function convertAnalyzersToGenerated(analyzers) {
-    if (!analyzers) {
-        return analyzers;
-    }
-    const result = [];
-    for (const analyzer of analyzers) {
-        switch (analyzer.odatatype) {
-            case "#Microsoft.Azure.Search.StandardAnalyzer":
-            case "#Microsoft.Azure.Search.StopAnalyzer":
-                result.push(analyzer);
-                break;
-            case "#Microsoft.Azure.Search.PatternAnalyzer":
-                result.push({
-                    ...analyzer,
-                    flags: analyzer.flags ? analyzer.flags.join("|") : undefined,
-                });
-                break;
-            case "#Microsoft.Azure.Search.CustomAnalyzer":
-                result.push({
-                    ...analyzer,
-                    tokenizerName: analyzer.tokenizerName,
-                });
-                break;
-        }
-    }
-    return result;
+  if (!analyzers) {
+    return analyzers;
+  }
+  const result = [];
+  for (const analyzer of analyzers) {
+    switch (analyzer.odatatype) {
+      case "#Microsoft.Azure.Search.StandardAnalyzer":
+      case "#Microsoft.Azure.Search.StopAnalyzer":
+        result.push(analyzer);
+        break;
+      case "#Microsoft.Azure.Search.PatternAnalyzer":
+        result.push(analyzer);
+        break;
+      case "#Microsoft.Azure.Search.CustomAnalyzer":
+        result.push({
+          ...analyzer,
+          tokenizer: analyzer.tokenizerName
+        });
+        break;
+    }
+  }
+  return result;
 }
 function convertAnalyzersToPublic(analyzers) {
-    if (!analyzers) {
-        return analyzers;
-    }
-    const result = [];
-    for (const analyzer of analyzers) {
-        switch (analyzer.odatatype) {
-            case "#Microsoft.Azure.Search.StandardAnalyzer":
-                result.push(analyzer);
-                break;
-            case "#Microsoft.Azure.Search.StopAnalyzer":
-                result.push(analyzer);
-                break;
-            case "#Microsoft.Azure.Search.PatternAnalyzer":
-                result.push({
-                    ...analyzer,
-                    flags: analyzer.flags
-                        ? analyzer.flags.split("|")
-                        : undefined,
-                });
-                break;
-            case "#Microsoft.Azure.Search.CustomAnalyzer":
-                result.push(analyzer);
-                break;
-        }
-    }
-    return result;
+  if (!analyzers) {
+    return void 0;
+  }
+  const result = [];
+  for (const analyzer of analyzers) {
+    switch (analyzer.odatatype) {
+      case "#Microsoft.Azure.Search.StandardAnalyzer":
+        result.push(analyzer);
+        break;
+      case "#Microsoft.Azure.Search.StopAnalyzer":
+        result.push(analyzer);
+        break;
+      case "#Microsoft.Azure.Search.PatternAnalyzer":
+        result.push({
+          ...analyzer
+        });
+        break;
+      case "#Microsoft.Azure.Search.CustomAnalyzer":
+        result.push(analyzer);
+        break;
+    }
+  }
+  return result;
 }
 function convertFieldsToPublic(fields) {
-    if (!fields) {
-        return fields;
-    }
-    return fields.map((field) => {
-        if (field.type === "Collection(Edm.ComplexType)" || field.type === "Edm.ComplexType") {
-            const result = {
-                name: field.name,
-                type: field.type,
-                fields: convertFieldsToPublic(field.fields),
-            };
-            return result;
-        }
-        else {
-            const type = field.type;
-            const synonymMapNames = field.synonymMaps;
-            const { retrievable, analyzer, searchAnalyzer, indexAnalyzer, normalizer, ...restField } = field;
-            const hidden = typeof retrievable === "boolean" ? !retrievable : retrievable;
-            const result = {
-                ...restField,
-                type,
-                hidden,
-                analyzerName: analyzer,
-                searchAnalyzerName: searchAnalyzer,
-                indexAnalyzerName: indexAnalyzer,
-                normalizerName: normalizer,
-                synonymMapNames,
-            };
-            return result;
-        }
-    });
+  if (!fields) {
+    return void 0;
+  }
+  return fields.map((field) => {
+    if (field.type === "Collection(Edm.ComplexType)" || field.type === "Edm.ComplexType") {
+      const result = {
+        name: field.name,
+        type: field.type,
+        fields: convertFieldsToPublic(field.fields)
+      };
+      return result;
+    } else {
+      const type = field.type;
+      const synonymMapNames = field.synonymMapNames;
+      const { retrievable, ...restField } = field;
+      const hidden = typeof retrievable === "boolean" ? !retrievable : retrievable;
+      const result = {
+        ...restField,
+        type,
+        hidden,
+        synonymMapNames
+      };
+      return result;
+    }
+  });
 }
 function convertFieldsToGenerated(fields) {
-    return fields?.map((field) => {
-        if ((0, serviceModels_js_1.isComplexField)(field)) {
-            return {
-                name: field.name,
-                type: field.type,
-                fields: convertFieldsToGenerated(field.fields),
-            };
-        }
-        else {
-            const { hidden, ...restField } = field;
-            const retrievable = typeof hidden === "boolean" ? !hidden : hidden;
-            return {
-                ...restField,
-                retrievable,
-                // modify API defaults to use less storage for simple types
-                searchable: field.searchable ?? false,
-                filterable: field.filterable ?? false,
-                facetable: field.facetable ?? false,
-                sortable: field.sortable ?? false,
-                analyzer: field.analyzerName,
-                searchAnalyzer: field.searchAnalyzerName,
-                indexAnalyzer: field.indexAnalyzerName,
-                synonymMaps: field.synonymMapNames,
-                normalizer: field.normalizerName,
-            };
-        }
-    });
-}
-function convertTokenizersToGenerated(tokenizers) {
-    if (!tokenizers) {
-        return tokenizers;
-    }
-    const result = [];
-    for (const tokenizer of tokenizers) {
-        if (tokenizer.odatatype === "#Microsoft.Azure.Search.PatternTokenizer") {
-            result.push({
-                ...tokenizer,
-                flags: tokenizer.flags ? tokenizer.flags.join("|") : undefined,
-            });
-        }
-        else {
-            result.push(tokenizer);
-        }
-    }
-    return result;
+  return fields?.map((field) => {
+    if ((0, import_serviceModels.isComplexField)(field)) {
+      return {
+        name: field.name,
+        type: field.type,
+        fields: convertFieldsToGenerated(field.fields)
+      };
+    } else {
+      const { hidden, ...restField } = field;
+      const retrievable = typeof hidden === "boolean" ? !hidden : hidden;
+      return {
+        ...restField,
+        retrievable,
+        // modify API defaults to use less storage for simple types
+        searchable: field.searchable ?? false,
+        filterable: field.filterable ?? false,
+        facetable: field.facetable ?? false,
+        sortable: field.sortable ?? false,
+        analyzerName: field.analyzerName,
+        searchAnalyzerName: field.searchAnalyzerName,
+        indexAnalyzerName: field.indexAnalyzerName,
+        synonymMapNames: field.synonymMapNames,
+        normalizerName: field.normalizerName
+      };
+    }
+  });
 }
 function convertTokenizersToPublic(tokenizers) {
-    if (!tokenizers) {
-        return tokenizers;
-    }
-    const result = [];
-    for (const tokenizer of tokenizers) {
-        if (tokenizer.odatatype === "#Microsoft.Azure.Search.PatternTokenizer") {
-            const patternTokenizer = tokenizer;
-            const flags = patternTokenizer.flags?.split("|");
-            result.push({
-                ...tokenizer,
-                flags,
-            });
-        }
-        else {
-            result.push(tokenizer);
-        }
-    }
-    return result;
+  if (!tokenizers) {
+    return void 0;
+  }
+  const result = [];
+  for (const tokenizer of tokenizers) {
+    result.push(tokenizer);
+  }
+  return result;
 }
 function convertSimilarityToGenerated(similarity) {
-    if (!similarity) {
-        return similarity;
-    }
+  if (!similarity) {
     return similarity;
+  }
+  return similarity;
 }
 function convertSimilarityToPublic(similarity) {
-    if (!similarity) {
-        return similarity;
-    }
-    if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
-        return similarity;
-    }
-    else {
-        return similarity;
-    }
+  if (!similarity) {
+    return void 0;
+  }
+  if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
+    return similarity;
+  } else {
+    return similarity;
+  }
 }
 function convertEncryptionKeyToPublic(encryptionKey) {
-    if (!encryptionKey) {
-        return encryptionKey;
-    }
-    const result = {
-        keyName: encryptionKey.keyName,
-        keyVersion: encryptionKey.keyVersion,
-        vaultUrl: encryptionKey.vaultUri,
-        identity: convertSearchIndexerDataIdentityToPublic(encryptionKey.identity),
-    };
-    if (encryptionKey.accessCredentials) {
-        result.applicationId = encryptionKey.accessCredentials.applicationId;
-        result.applicationSecret = encryptionKey.accessCredentials.applicationSecret;
-    }
-    return result;
+  if (!encryptionKey) {
+    return void 0;
+  }
+  const result = {
+    keyName: encryptionKey.keyName,
+    keyVersion: encryptionKey.keyVersion,
+    vaultUrl: encryptionKey.vaultUri,
+    identity: convertSearchIndexerDataIdentityToPublic(encryptionKey.identity),
+    applicationId: encryptionKey.applicationId,
+    applicationSecret: encryptionKey.applicationSecret
+  };
+  return result;
 }
 function convertEncryptionKeyToGenerated(encryptionKey) {
-    if (!encryptionKey) {
-        return encryptionKey;
-    }
-    const result = {
-        keyName: encryptionKey.keyName,
-        keyVersion: encryptionKey.keyVersion,
-        vaultUri: encryptionKey.vaultUrl,
-        identity: encryptionKey.identity,
-    };
-    if (encryptionKey.applicationId) {
-        result.accessCredentials = {
-            applicationId: encryptionKey.applicationId,
-            applicationSecret: encryptionKey.applicationSecret,
-        };
-    }
-    return result;
+  if (!encryptionKey) {
+    return void 0;
+  }
+  const result = {
+    keyName: encryptionKey.keyName,
+    keyVersion: encryptionKey.keyVersion,
+    vaultUri: encryptionKey.vaultUrl,
+    identity: encryptionKey.identity,
+    applicationId: encryptionKey.applicationId,
+    applicationSecret: encryptionKey.applicationSecret
+  };
+  return result;
 }
 function generatedIndexToPublicIndex(generatedIndex) {
-    const { charFilters, tokenFilters, scoringProfiles, encryptionKey, analyzers, tokenizers, fields, similarity, vectorSearch, ...rest } = generatedIndex;
-    return {
-        ...rest,
-        scoringProfiles: scoringProfiles,
-        tokenFilters: tokenFilters,
-        charFilters: charFilters,
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-        analyzers: convertAnalyzersToPublic(analyzers),
-        tokenizers: convertTokenizersToPublic(tokenizers),
-        fields: convertFieldsToPublic(fields),
-        similarity: convertSimilarityToPublic(similarity),
-        vectorSearch: generatedVectorSearchToPublicVectorSearch(vectorSearch),
-    };
+  const {
+    charFilters,
+    tokenFilters,
+    scoringProfiles,
+    encryptionKey,
+    analyzers,
+    tokenizers,
+    fields,
+    similarity,
+    vectorSearch,
+    ...rest
+  } = generatedIndex;
+  return {
+    ...rest,
+    scoringProfiles,
+    tokenFilters,
+    charFilters,
+    encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
+    analyzers: convertAnalyzersToPublic(analyzers),
+    tokenizers: convertTokenizersToPublic(tokenizers),
+    fields: convertFieldsToPublic(fields),
+    similarity: convertSimilarityToPublic(similarity),
+    vectorSearch: generatedVectorSearchToPublicVectorSearch(vectorSearch)
+  };
 }
 function generatedVectorSearchVectorizerToPublicVectorizer(generatedVectorizer) {
-    if (!generatedVectorizer) {
-        return generatedVectorizer;
-    }
-    const knownVectorizerDeserializers = {
-        azureOpenAI: () => {
-            const { parameters } = generatedVectorizer;
-            const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
-            const vectorizer = {
-                ...generatedVectorizer,
-                parameters: { ...parameters, authIdentity },
-            };
-            return vectorizer;
-        },
-        customWebApi: () => {
-            const { parameters } = generatedVectorizer;
-            const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
-            const vectorizer = {
-                ...generatedVectorizer,
-                parameters: { ...parameters, authIdentity },
-            };
-            return vectorizer;
-        },
-        aiServicesVision: () => {
-            const generatedVisionVectorizer = generatedVectorizer;
-            const { aIServicesVisionParameters: generatedParameters } = generatedVisionVectorizer;
-            const parameters = generatedParameters
-                ? {
-                    ...generatedParameters,
-                    modelVersion: generatedParameters.modelVersion ?? undefined,
-                    resourceUri: generatedParameters.resourceUri,
-                    authIdentity: convertSearchIndexerDataIdentityToPublic(generatedParameters.authIdentity),
-                }
-                : undefined;
-            const vectorizer = {
-                ...generatedVisionVectorizer,
-                parameters,
-            };
-            return vectorizer;
-        },
-        aml: () => {
-            const generatedAMLVectorizer = generatedVectorizer;
-            const vectorizer = {
-                ...generatedAMLVectorizer,
-                amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(generatedAMLVectorizer.aMLParameters),
-            };
-            return vectorizer;
-        },
-    };
-    const defaultDeserializer = () => {
-        logger_js_1.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
-        return generatedVectorizer;
-    };
-    return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
+  if (!generatedVectorizer) {
+    return void 0;
+  }
+  const knownVectorizerDeserializers = {
+    azureOpenAI: () => {
+      const { parameters } = generatedVectorizer;
+      const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
+      const vectorizer = {
+        ...generatedVectorizer,
+        parameters: { ...parameters, authIdentity }
+      };
+      return vectorizer;
+    },
+    customWebApi: () => {
+      const { webApiParameters } = generatedVectorizer;
+      const authIdentity = convertSearchIndexerDataIdentityToPublic(webApiParameters?.authIdentity);
+      const vectorizer = {
+        ...generatedVectorizer,
+        parameters: { ...webApiParameters, authIdentity }
+      };
+      return vectorizer;
+    },
+    aml: () => {
+      const generatedAMLVectorizer = generatedVectorizer;
+      const vectorizer = {
+        ...generatedAMLVectorizer,
+        amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(
+          generatedAMLVectorizer.amlParameters
+        )
+      };
+      return vectorizer;
+    }
+  };
+  const defaultDeserializer = () => {
+    import_logger.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
+    return generatedVectorizer;
+  };
+  return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
 }
 function generatedKnowledgeSourceVectorizerToPublicVectorizer(generatedVectorizer) {
-    if (!generatedVectorizer) {
-        return generatedVectorizer;
-    }
-    const knownVectorizerDeserializers = {
-        azureOpenAI: () => {
-            const { parameters } = generatedVectorizer;
-            const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
-            const vectorizer = {
-                ...generatedVectorizer,
-                parameters: { ...parameters, authIdentity },
-            };
-            return vectorizer;
-        },
-    };
-    const defaultDeserializer = () => {
-        logger_js_1.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
-        return generatedVectorizer;
-    };
-    return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
+  if (!generatedVectorizer) {
+    return generatedVectorizer;
+  }
+  const knownVectorizerDeserializers = {
+    azureOpenAI: () => {
+      const { parameters } = generatedVectorizer;
+      const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
+      const vectorizer = {
+        ...generatedVectorizer,
+        parameters: { ...parameters, authIdentity }
+      };
+      return vectorizer;
+    }
+  };
+  const defaultDeserializer = () => {
+    import_logger.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
+    return generatedVectorizer;
+  };
+  return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
 }
 function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
-    if (!aMLParameters) {
-        return aMLParameters;
-    }
-    const { resourceId, authenticationKey, scoringUri } = aMLParameters;
-    // Sensitive to case order
-    switch (true) {
-        case resourceId !== undefined && resourceId !== null: {
-            return {
-                ...aMLParameters,
-                authKind: "token",
-            };
-        }
-        case authenticationKey !== undefined && authenticationKey !== null: {
-            return {
-                ...aMLParameters,
-                authKind: "key",
-            };
-        }
-        case scoringUri !== undefined && scoringUri !== null: {
-            return {
-                ...aMLParameters,
-                authKind: "none",
-            };
-        }
-    }
-    logger_js_1.logger.warning("Unknown AML parameter kind");
-    return aMLParameters;
+  if (!aMLParameters) {
+    return void 0;
+  }
+  const { resourceId, authenticationKey, scoringUri } = aMLParameters;
+  switch (true) {
+    case (resourceId !== void 0 && resourceId !== null): {
+      return {
+        ...aMLParameters,
+        authKind: "token"
+      };
+    }
+    case (authenticationKey !== void 0 && authenticationKey !== null): {
+      return {
+        ...aMLParameters,
+        apiKey: authenticationKey,
+        authKind: "key"
+      };
+    }
+    case (scoringUri !== void 0 && scoringUri !== null): {
+      return {
+        ...aMLParameters,
+        authKind: "none"
+      };
+    }
+  }
+  import_logger.logger.warning("Unknown AML parameter kind");
+  return aMLParameters;
 }
 function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
-    if (!generatedAlgorithmConfiguration) {
-        return generatedAlgorithmConfiguration;
-    }
-    if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
-        const algorithmConfiguration = generatedAlgorithmConfiguration;
-        const metric = algorithmConfiguration.parameters?.metric;
-        return {
-            ...algorithmConfiguration,
-            parameters: { ...algorithmConfiguration.parameters, metric },
-        };
-    }
-    throw Error("Unsupported algorithm configuration");
-}
-function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
-    if (!vectorSearch) {
-        return vectorSearch;
-    }
+  if (!generatedAlgorithmConfiguration) {
+    return void 0;
+  }
+  if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
+    const algorithmConfiguration = generatedAlgorithmConfiguration;
+    const metric = algorithmConfiguration.parameters?.metric;
     return {
-        ...vectorSearch,
-        algorithms: vectorSearch.algorithms?.map(generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration),
-        vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer),
+      ...algorithmConfiguration,
+      parameters: { ...algorithmConfiguration.parameters, metric }
     };
+  }
+  throw Error("Unsupported algorithm configuration");
+}
+function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
+  if (!vectorSearch) {
+    return void 0;
+  }
+  return {
+    ...vectorSearch,
+    algorithms: vectorSearch.algorithms?.map(
+      generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration
+    ),
+    vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer)
+  };
 }
 function generatedSearchResultToPublicSearchResult(results) {
-    const returnValues = results.map((result) => {
-        const { _score: score, _highlights: highlights, _rerankerScore: rerankerScore, _rerankerBoostedScore: rerankerBoostedScore, _captions: captions, _documentDebugInfo: documentDebugInfo, ...restProps } = result;
-        const obj = {
-            score,
-            highlights,
-            rerankerScore,
-            rerankerBoostedScore,
-            captions,
-            documentDebugInfo,
-            document: restProps,
-        };
-        return obj;
-    });
-    return returnValues;
+  const returnValues = results.map(
+    (result) => {
+      const {
+        score,
+        highlights,
+        rerankerScore,
+        rerankerBoostedScore,
+        captions,
+        documentDebugInfo,
+        additionalProperties
+      } = result;
+      const obj = {
+        score,
+        highlights,
+        rerankerScore,
+        rerankerBoostedScore,
+        captions: convertGeneratedCaptionsToPublic(captions),
+        documentDebugInfo,
+        // The generated code puts document fields in additionalProperties
+        document: additionalProperties ?? {}
+      };
+      return obj;
+    }
+  );
+  return returnValues;
 }
 function generatedSuggestDocumentsResultToPublicSuggestDocumentsResult(searchDocumentsResult) {
-    const results = searchDocumentsResult.results.map((element) => {
-        const { _text, ...restProps } = element;
-        const obj = {
-            text: _text,
-            document: restProps,
-        };
-        return obj;
-    });
-    const result = {
-        results: results,
-        coverage: searchDocumentsResult.coverage,
+  const results = searchDocumentsResult.results.map((element) => {
+    const { text, additionalProperties } = element;
+    const obj = {
+      text,
+      // The generated code puts document fields in additionalProperties
+      document: additionalProperties ?? {}
     };
-    return result;
+    return obj;
+  });
+  const result = {
+    results,
+    coverage: searchDocumentsResult.coverage
+  };
+  return result;
 }
 function publicIndexToGeneratedIndex(index) {
-    const { encryptionKey, tokenFilters, analyzers, tokenizers, fields, similarity } = index;
-    return {
-        ...index,
-        encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
-        tokenFilters: convertTokenFiltersToGenerated(tokenFilters),
-        analyzers: convertAnalyzersToGenerated(analyzers),
-        tokenizers: convertTokenizersToGenerated(tokenizers),
-        fields: convertFieldsToGenerated(fields) ?? [],
-        similarity: convertSimilarityToGenerated(similarity),
-    };
+  const { encryptionKey, tokenFilters, analyzers, fields, similarity } = index;
+  return {
+    ...index,
+    encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
+    tokenFilters: convertTokenFiltersToGenerated(tokenFilters),
+    analyzers: convertAnalyzersToGenerated(analyzers),
+    fields: convertFieldsToGenerated(fields) ?? [],
+    similarity: convertSimilarityToGenerated(similarity)
+  };
 }
 function generatedSkillsetToPublicSkillset(generatedSkillset) {
-    const { skills, cognitiveServicesAccount, knowledgeStore, encryptionKey, indexProjection, ...props } = generatedSkillset;
-    return {
-        ...props,
-        skills: convertSkillsToPublic(skills),
-        cognitiveServicesAccount: convertCognitiveServicesAccountToPublic(cognitiveServicesAccount),
-        knowledgeStore: convertKnowledgeStoreToPublic(knowledgeStore),
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-        indexProjection: indexProjection,
-    };
+  const {
+    skills,
+    cognitiveServicesAccount,
+    knowledgeStore,
+    encryptionKey,
+    indexProjection,
+    ...props
+  } = generatedSkillset;
+  return {
+    ...props,
+    skills: convertSkillsToPublic(skills),
+    cognitiveServicesAccount: convertCognitiveServicesAccountToPublic(cognitiveServicesAccount),
+    knowledgeStore: convertKnowledgeStoreToPublic(knowledgeStore),
+    encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
+    indexProjection
+  };
 }
 function publicSkillsetToGeneratedSkillset(skillset) {
-    const { cognitiveServicesAccount, encryptionKey } = skillset;
-    return {
-        ...skillset,
-        cognitiveServicesAccount: convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount),
-        encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
-    };
+  const { cognitiveServicesAccount, encryptionKey } = skillset;
+  return {
+    ...skillset,
+    cognitiveServicesAccount: convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount),
+    encryptionKey: convertEncryptionKeyToGenerated(encryptionKey)
+  };
 }
 function generatedSynonymMapToPublicSynonymMap(synonymMap) {
-    const result = {
-        name: synonymMap.name,
-        encryptionKey: convertEncryptionKeyToPublic(synonymMap.encryptionKey),
-        etag: synonymMap.etag,
-        synonyms: [],
-    };
-    if (synonymMap.synonyms) {
-        result.synonyms = synonymMap.synonyms.split("\n");
-    }
-    return result;
+  const result = {
+    name: synonymMap.name,
+    encryptionKey: convertEncryptionKeyToPublic(synonymMap.encryptionKey),
+    etag: synonymMap.eTag,
+    synonyms: []
+  };
+  if (synonymMap.synonyms) {
+    result.synonyms = synonymMap.synonyms;
+  }
+  return result;
 }
 function publicSynonymMapToGeneratedSynonymMap(synonymMap) {
-    const result = {
-        name: synonymMap.name,
-        format: "solr",
-        encryptionKey: convertEncryptionKeyToGenerated(synonymMap.encryptionKey),
-        etag: synonymMap.etag,
-        synonyms: synonymMap.synonyms.join("\n"),
-    };
-    result.encryptionKey = convertEncryptionKeyToGenerated(synonymMap.encryptionKey);
-    return result;
+  const result = {
+    name: synonymMap.name,
+    format: "solr",
+    encryptionKey: convertEncryptionKeyToGenerated(synonymMap.encryptionKey),
+    eTag: synonymMap.etag,
+    synonyms: synonymMap.synonyms
+  };
+  result.encryptionKey = convertEncryptionKeyToGenerated(synonymMap.encryptionKey);
+  return result;
 }
 function publicSearchIndexerToGeneratedSearchIndexer(indexer) {
-    return {
-        ...indexer,
-        encryptionKey: convertEncryptionKeyToGenerated(indexer.encryptionKey),
-    };
+  return {
+    ...indexer,
+    encryptionKey: convertEncryptionKeyToGenerated(indexer.encryptionKey)
+  };
 }
 function generatedSearchIndexerToPublicSearchIndexer(indexer) {
-    const { parsingMode, dataToExtract, imageAction, pdfTextRotationAlgorithm, executionEnvironment, } = indexer.parameters?.configuration ?? {};
-    const configuration = indexer.parameters
-        ?.configuration && {
-        ...indexer.parameters?.configuration,
-        parsingMode: parsingMode,
-        dataToExtract: dataToExtract,
-        imageAction: imageAction,
-        pdfTextRotationAlgorithm: pdfTextRotationAlgorithm,
-        executionEnvironment: executionEnvironment,
-    };
-    const parameters = {
-        ...indexer.parameters,
-        configuration,
-    };
-    return {
-        ...indexer,
-        parameters,
-        encryptionKey: convertEncryptionKeyToPublic(indexer.encryptionKey),
-        cache: convertSearchIndexerCacheToPublic(indexer.cache),
-    };
+  const {
+    parsingMode,
+    dataToExtract,
+    imageAction,
+    pdfTextRotationAlgorithm,
+    executionEnvironment
+  } = indexer.parameters?.configuration ?? {};
+  const configuration = indexer.parameters?.configuration && {
+    ...indexer.parameters?.configuration,
+    parsingMode,
+    dataToExtract,
+    imageAction,
+    pdfTextRotationAlgorithm,
+    executionEnvironment,
+    markdownParsingSubmode: indexer.parameters?.configuration?.markdownParsingSubmode,
+    markdownHeaderDepth: indexer.parameters?.configuration?.markdownHeaderDepth
+  };
+  const parameters = {
+    ...indexer.parameters,
+    configuration,
+    batchSize: indexer.parameters?.batchSize,
+    maxFailedItems: indexer.parameters?.maxFailedItems,
+    maxFailedItemsPerBatch: indexer.parameters?.maxFailedItemsPerBatch
+  };
+  return {
+    ...indexer,
+    parameters,
+    encryptionKey: convertEncryptionKeyToPublic(indexer.encryptionKey),
+    schedule: indexer.schedule,
+    isDisabled: indexer.isDisabled
+  };
 }
 function publicDataSourceToGeneratedDataSource(dataSource) {
-    return {
-        name: dataSource.name,
-        description: dataSource.description,
-        type: dataSource.type,
-        credentials: {
-            connectionString: dataSource.connectionString,
-        },
-        container: dataSource.container,
-        identity: dataSource.identity,
-        etag: dataSource.etag,
-        dataChangeDetectionPolicy: dataSource.dataChangeDetectionPolicy,
-        dataDeletionDetectionPolicy: dataSource.dataDeletionDetectionPolicy,
-        encryptionKey: convertEncryptionKeyToGenerated(dataSource.encryptionKey),
-    };
+  return {
+    name: dataSource.name,
+    description: dataSource.description,
+    type: dataSource.type,
+    connectionString: dataSource.connectionString,
+    container: dataSource.container,
+    identity: dataSource.identity,
+    eTag: dataSource.etag,
+    dataChangeDetectionPolicy: dataSource.dataChangeDetectionPolicy,
+    dataDeletionDetectionPolicy: dataSource.dataDeletionDetectionPolicy,
+    encryptionKey: convertEncryptionKeyToGenerated(dataSource.encryptionKey)
+  };
 }
 function generatedDataSourceToPublicDataSource(dataSource) {
-    return {
-        name: dataSource.name,
-        description: dataSource.name,
-        type: dataSource.type,
-        connectionString: dataSource.credentials.connectionString,
-        container: dataSource.container,
-        identity: convertSearchIndexerDataIdentityToPublic(dataSource.identity),
-        etag: dataSource.etag,
-        dataChangeDetectionPolicy: convertDataChangeDetectionPolicyToPublic(dataSource.dataChangeDetectionPolicy),
-        dataDeletionDetectionPolicy: convertDataDeletionDetectionPolicyToPublic(dataSource.dataDeletionDetectionPolicy),
-        encryptionKey: convertEncryptionKeyToPublic(dataSource.encryptionKey),
-    };
+  return {
+    name: dataSource.name,
+    description: dataSource.description,
+    type: dataSource.type,
+    connectionString: dataSource.connectionString,
+    container: dataSource.container,
+    identity: convertSearchIndexerDataIdentityToPublic(dataSource.identity),
+    etag: dataSource.eTag,
+    dataChangeDetectionPolicy: convertDataChangeDetectionPolicyToPublic(
+      dataSource.dataChangeDetectionPolicy
+    ),
+    dataDeletionDetectionPolicy: convertDataDeletionDetectionPolicyToPublic(
+      dataSource.dataDeletionDetectionPolicy
+    ),
+    encryptionKey: convertEncryptionKeyToPublic(dataSource.encryptionKey)
+  };
 }
 function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdentity) {
-    if (!searchIndexerDataIdentity) {
-        return searchIndexerDataIdentity;
-    }
-    if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
-        return searchIndexerDataIdentity;
-    }
-    else {
-        return searchIndexerDataIdentity;
-    }
+  if (!searchIndexerDataIdentity) {
+    return void 0;
+  }
+  if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
+    return searchIndexerDataIdentity;
+  } else {
+    return searchIndexerDataIdentity;
+  }
 }
 function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
-    if (!dataChangeDetectionPolicy) {
-        return dataChangeDetectionPolicy;
-    }
-    if (dataChangeDetectionPolicy.odatatype ===
-        "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
-        return dataChangeDetectionPolicy;
-    }
-    else {
-        return dataChangeDetectionPolicy;
-    }
+  if (!dataChangeDetectionPolicy) {
+    return void 0;
+  }
+  if (dataChangeDetectionPolicy.odatatype === "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
+    return dataChangeDetectionPolicy;
+  } else {
+    return dataChangeDetectionPolicy;
+  }
 }
 function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
-    if (!dataDeletionDetectionPolicy) {
-        return dataDeletionDetectionPolicy;
-    }
-    return dataDeletionDetectionPolicy;
-}
-function getRandomIntegerInclusive(min, max) {
-    // Make sure inputs are integers.
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    // Pick a random offset from zero to the size of the range.
-    // Since Math.random() can never return 1, we have to make the range one larger
-    // in order to be inclusive of the maximum value after we take the floor.
-    const offset = Math.floor(Math.random() * (max - min + 1));
-    return offset + min;
+  if (!dataDeletionDetectionPolicy) {
+    return void 0;
+  }
+  return dataDeletionDetectionPolicy;
 }
 function convertKnowledgeStoreToPublic(knowledgeStore) {
-    if (!knowledgeStore) {
-        return knowledgeStore;
-    }
-    return {
-        ...knowledgeStore,
-        identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity),
-    };
-}
-function convertSearchIndexerCacheToPublic(cache) {
-    if (!cache) {
-        return cache;
-    }
-    return {
-        ...cache,
-        identity: convertSearchIndexerDataIdentityToPublic(cache.identity),
-    };
+  if (!knowledgeStore) {
+    return void 0;
+  }
+  return {
+    ...knowledgeStore,
+    identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity)
+  };
 }
 function convertKnowledgeBaseToPublic(knowledgeBase) {
-    if (!knowledgeBase) {
-        return knowledgeBase;
-    }
-    return {
-        ...knowledgeBase,
-        models: knowledgeBase.models.map((model) => convertKnowledgeBaseModelToPublic(model)),
-        encryptionKey: convertEncryptionKeyToPublic(knowledgeBase.encryptionKey),
-    };
+  if (!knowledgeBase) {
+    throw new Error("Knowledge base is undefined");
+  }
+  return {
+    ...knowledgeBase,
+    etag: knowledgeBase.etag,
+    models: (knowledgeBase.models ?? []).map((model) => convertKnowledgeBaseModelToPublic(model)),
+    encryptionKey: convertEncryptionKeyToPublic(knowledgeBase.encryptionKey)
+  };
 }
 function convertKnowledgeBaseToGenerated(knowledgeBase) {
-    if (!knowledgeBase) {
-        return knowledgeBase;
-    }
-    return {
-        ...knowledgeBase,
-        encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey),
-    };
+  if (!knowledgeBase) {
+    return void 0;
+  }
+  return {
+    ...knowledgeBase,
+    etag: knowledgeBase.etag,
+    encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey)
+  };
 }
 function convertKnowledgeSourceToPublic(knowledgeSource) {
-    if (!knowledgeSource) {
-        return knowledgeSource;
-    }
-    switch (knowledgeSource.kind) {
-        case "searchIndex": {
-            const { encryptionKey } = knowledgeSource;
-            return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToPublic(encryptionKey) };
-        }
-        case "azureBlob": {
-            const { encryptionKey, azureBlobParameters } = knowledgeSource;
-            return {
-                ...knowledgeSource,
-                encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-                azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters),
-            };
-        }
-        case "indexedSharePoint": {
-            const { encryptionKey, indexedSharePointParameters } = knowledgeSource;
-            return {
-                ...knowledgeSource,
-                encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-                indexedSharePointParameters: {
-                    ...indexedSharePointParameters,
-                    ingestionParameters: convertKnowledgeIngestionParametersToPublic(indexedSharePointParameters.ingestionParameters),
-                },
-            };
-        }
-        case "indexedOneLake": {
-            const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
-            return {
-                ...knowledgeSource,
-                encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-                indexedOneLakeParameters: {
-                    ...indexedOneLakeParameters,
-                    ingestionParameters: convertKnowledgeIngestionParametersToPublic(indexedOneLakeParameters.ingestionParameters),
-                },
-            };
-        }
-        case "remoteSharePoint": {
-            const { encryptionKey } = knowledgeSource;
-            return {
-                ...knowledgeSource,
-                encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-            };
-        }
-        case "web": {
-            const { encryptionKey } = knowledgeSource;
-            return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToPublic(encryptionKey) };
+  if (!knowledgeSource) {
+    return void 0;
+  }
+  switch (knowledgeSource.kind) {
+    case "searchIndex": {
+      const { encryptionKey } = knowledgeSource;
+      return {
+        ...knowledgeSource,
+        encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
+      };
+    }
+    case "azureBlob": {
+      const { encryptionKey, azureBlobParameters } = knowledgeSource;
+      return {
+        ...knowledgeSource,
+        kind: "azureBlob",
+        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
+        azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters)
+      };
+    }
+    case "indexedOneLake": {
+      const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
+      return {
+        ...knowledgeSource,
+        kind: "indexedOneLake",
+        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
+        indexedOneLakeParameters: {
+          fabricWorkspaceId: indexedOneLakeParameters.fabricWorkspaceId,
+          lakehouseId: indexedOneLakeParameters.lakehouseId,
+          ingestionParameters: convertKnowledgeIngestionParametersToPublic(
+            indexedOneLakeParameters.ingestionParameters
+          ),
+          targetPath: indexedOneLakeParameters.targetPath,
+          createdResources: indexedOneLakeParameters.createdResources?.additionalProperties
         }
+      };
+    }
+    case "web": {
+      const { encryptionKey } = knowledgeSource;
+      return {
+        ...knowledgeSource,
+        kind: "web",
+        encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
+      };
     }
+    default: {
+      import_logger.logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
+      return void 0;
+    }
+  }
 }
 function convertKnowledgeSourceToGenerated(knowledgeSource) {
-    if (!knowledgeSource) {
-        return knowledgeSource;
-    }
-    const { encryptionKey } = knowledgeSource;
-    return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToGenerated(encryptionKey) };
+  if (!knowledgeSource) {
+    return void 0;
+  }
+  const { encryptionKey } = knowledgeSource;
+  return {
+    ...knowledgeSource,
+    encryptionKey: convertEncryptionKeyToGenerated(encryptionKey)
+  };
 }
 function convertKnowledgeIngestionParametersToPublic(params) {
-    if (!params) {
-        return params;
-    }
-    const { embeddingModel, chatCompletionModel, identity, ...rest } = params;
-    return {
-        ...rest,
-        embeddingModel: !embeddingModel
-            ? embeddingModel
-            : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
-        identity: convertSearchIndexerDataIdentityToPublic(identity),
-        chatCompletionModel: !chatCompletionModel
-            ? chatCompletionModel
-            : convertKnowledgeBaseModelToPublic(chatCompletionModel),
-    };
+  if (!params) {
+    return void 0;
+  }
+  const { embeddingModel, chatCompletionModel, identity, ...rest } = params;
+  return {
+    ...rest,
+    embeddingModel: !embeddingModel ? embeddingModel : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
+    identity: convertSearchIndexerDataIdentityToPublic(identity),
+    chatCompletionModel: !chatCompletionModel ? chatCompletionModel : convertKnowledgeBaseModelToPublic(chatCompletionModel)
+  };
 }
 function convertAzureBlobKnowledgeSourceParametersToPublic(params) {
-    if (!params) {
-        return params;
-    }
-    const { ingestionParameters, ...rest } = params;
-    if (!ingestionParameters) {
-        return { ...rest };
-    }
-    const { embeddingModel, chatCompletionModel, identity } = ingestionParameters;
-    return {
-        ...rest,
-        embeddingModel: !embeddingModel
-            ? embeddingModel
-            : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
-        identity: convertSearchIndexerDataIdentityToPublic(identity),
-        chatCompletionModel: !chatCompletionModel
-            ? chatCompletionModel
-            : convertKnowledgeBaseModelToPublic(chatCompletionModel),
-    };
+  if (!params) {
+    return void 0;
+  }
+  const { embeddingModel, chatCompletionModel, identity, ...rest } = params.ingestionParameters ?? {};
+  return {
+    ...rest,
+    embeddingModel: !embeddingModel ? embeddingModel : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
+    identity: convertSearchIndexerDataIdentityToPublic(identity),
+    connectionString: params.connectionString,
+    containerName: params.containerName,
+    chatCompletionModel: !chatCompletionModel ? chatCompletionModel : convertKnowledgeBaseModelToPublic(chatCompletionModel)
+  };
 }
 function convertKnowledgeBaseModelToPublic(model) {
-    switch (model.kind) {
-        case "azureOpenAI": {
-            const { azureOpenAIParameters, ...rest } = model;
-            return {
-                ...rest,
-                azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters),
-            };
-        }
-        default: {
-            logger_js_1.logger.warning("Unknown knowledge base model kind");
-            return model;
-        }
+  switch (model.kind) {
+    case "azureOpenAI": {
+      const { azureOpenAIParameters, ...rest } = model;
+      return {
+        ...rest,
+        azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters)
+      };
     }
+    default: {
+      import_logger.logger.warning("Unknown knowledge base model kind");
+      return model;
+    }
+  }
 }
 function convertAzureOpenAIParametersToPublic(params) {
-    return { ...params, authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity) };
-}
-//# sourceMappingURL=serviceUtils.js.map
+  return {
+    ...params,
+    authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity)
+  };
+}
+function mapPagedAsyncIterable(iter, mapper) {
+  return {
+    async next() {
+      const result = await iter.next();
+      return {
+        ...result,
+        value: result.value && mapper(result.value)
+      };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async *byPage(settings) {
+      const iteratorByPage = iter.byPage(settings);
+      for await (const page of iteratorByPage) {
+        yield page.map(mapper);
+      }
+    }
+  };
+}
+function convertPublicActionsToGeneratedActions(actions) {
+  return actions.map((action) => {
+    const { __actionType, ...documentProperties } = action;
+    return {
+      actionType: __actionType,
+      additionalProperties: documentProperties
+    };
+  });
+}
+function convertGeneratedFacetResultToPublic(facetResult) {
+  const { additionalProperties, ...rest } = facetResult;
+  return {
+    ...additionalProperties,
+    ...rest,
+    additionalProperties
+  };
+}
+function convertGeneratedFacetsToPublic(facets) {
+  if (!facets) {
+    return facets;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(facets)) {
+    result[key] = value.map(convertGeneratedFacetResultToPublic);
+  }
+  return result;
+}
+function convertGeneratedQueryAnswerResultToPublic(answerResult) {
+  const { additionalProperties, ...rest } = answerResult;
+  return {
+    ...additionalProperties,
+    ...rest,
+    additionalProperties
+  };
+}
+function convertGeneratedAnswersToPublic(answers) {
+  if (!answers) {
+    return answers;
+  }
+  return answers.map(convertGeneratedQueryAnswerResultToPublic);
+}
+function convertGeneratedQueryCaptionResultToPublic(captionResult) {
+  const { additionalProperties, ...rest } = captionResult;
+  return {
+    ...additionalProperties,
+    ...rest,
+    additionalProperties
+  };
+}
+function convertGeneratedCaptionsToPublic(captions) {
+  if (!captions) {
+    return captions;
+  }
+  return captions.map(convertGeneratedQueryCaptionResultToPublic);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertCognitiveServicesAccountToGenerated,
+  convertCognitiveServicesAccountToPublic,
+  convertDataChangeDetectionPolicyToPublic,
+  convertDataDeletionDetectionPolicyToPublic,
+  convertFieldsToGenerated,
+  convertFieldsToPublic,
+  convertGeneratedAnswersToPublic,
+  convertGeneratedCaptionsToPublic,
+  convertGeneratedFacetResultToPublic,
+  convertGeneratedFacetsToPublic,
+  convertGeneratedQueryAnswerResultToPublic,
+  convertGeneratedQueryCaptionResultToPublic,
+  convertKnowledgeBaseToGenerated,
+  convertKnowledgeBaseToPublic,
+  convertKnowledgeSourceToGenerated,
+  convertKnowledgeSourceToPublic,
+  convertPublicActionsToGeneratedActions,
+  convertSearchIndexerDataIdentityToPublic,
+  convertSimilarityToGenerated,
+  convertSimilarityToPublic,
+  convertSkillsToPublic,
+  convertTokenFiltersToGenerated,
+  defaultServiceVersion,
+  generatedDataSourceToPublicDataSource,
+  generatedIndexToPublicIndex,
+  generatedKnowledgeSourceVectorizerToPublicVectorizer,
+  generatedSearchIndexerToPublicSearchIndexer,
+  generatedSearchResultToPublicSearchResult,
+  generatedSkillsetToPublicSkillset,
+  generatedSuggestDocumentsResultToPublicSuggestDocumentsResult,
+  generatedSynonymMapToPublicSynonymMap,
+  generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration,
+  generatedVectorSearchToPublicVectorSearch,
+  generatedVectorSearchVectorizerToPublicVectorizer,
+  mapPagedAsyncIterable,
+  publicDataSourceToGeneratedDataSource,
+  publicIndexToGeneratedIndex,
+  publicSearchIndexerToGeneratedSearchIndexer,
+  publicSkillsetToGeneratedSkillset,
+  publicSynonymMapToGeneratedSynonymMap
+});
+//# sourceMappingURL=serviceUtils.js.map