@azure/search-documents 12.3.0-alpha.20260310.2 → 13.0.0

package/dist/esm/serviceUtils.js

@@ -1,906 +1,817 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 import { logger } from "./logger.js";
 import { isComplexField } from "./serviceModels.js";
-const defaultServiceVersion = "2025-11-01-Preview";
+export 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;
-  }
-  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.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)
-      };
-    }
-  };
-  const defaultDeserializer = () => {
-    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;
+export function convertSkillsToPublic(skills) {
+    if (!skills) {
+        return [];
+    }
+    // This validation has already GAed
+    return skills.filter((skill) => knownSkills[skill.odatatype]);
+}
+export 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.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
+            return cognitiveServicesAccount;
+        }
+    }
+}
+export function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount) {
+    if (!cognitiveServicesAccount) {
+        return undefined;
+    }
+    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 = () => {
+        logger.warning(`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`);
+        return cognitiveServicesAccount;
+    };
+    return (deserializers[cognitiveServicesAccount.odatatype] ?? defaultDeserializer)();
+}
+export function convertTokenFiltersToGenerated(tokenFilters) {
+    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);
-        break;
-      case "#Microsoft.Azure.Search.CustomAnalyzer":
-        result.push({
-          ...analyzer,
-          tokenizer: 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
-        });
-        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.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 (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
-      };
-    }
-  });
+    if (!analyzers) {
+        return undefined;
+    }
+    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;
+}
+export function convertFieldsToPublic(fields) {
+    if (!fields) {
+        return undefined;
+    }
+    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;
+        }
+    });
+}
+export function convertFieldsToGenerated(fields) {
+    return fields?.map((field) => {
+        if (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) {
-    result.push(tokenizer);
-  }
-  return result;
-}
-function convertSimilarityToGenerated(similarity) {
-  if (!similarity) {
-    return similarity;
-  }
-  return similarity;
+    if (!tokenizers) {
+        return undefined;
+    }
+    const result = [];
+    for (const tokenizer of tokenizers) {
+        result.push(tokenizer);
+    }
+    return result;
 }
-function convertSimilarityToPublic(similarity) {
-  if (!similarity) {
-    return similarity;
-  }
-  if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
-    return similarity;
-  } else {
+export function convertSimilarityToGenerated(similarity) {
+    if (!similarity) {
+        return similarity;
+    }
     return similarity;
-  }
+}
+export function convertSimilarityToPublic(similarity) {
+    if (!similarity) {
+        return undefined;
+    }
+    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),
-    applicationId: encryptionKey.applicationId,
-    applicationSecret: encryptionKey.applicationSecret
-  };
-  return result;
+    if (!encryptionKey) {
+        return undefined;
+    }
+    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,
-    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,
-    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 { webApiParameters } = generatedVectorizer;
-      const authIdentity = convertSearchIndexerDataIdentityToPublic(webApiParameters?.authIdentity);
-      const vectorizer = {
-        ...generatedVectorizer,
-        parameters: { ...webApiParameters, authIdentity }
-      };
-      return vectorizer;
-    },
-    aiServicesVision: () => {
-      const generatedVisionVectorizer = generatedVectorizer;
-      const { aiServicesVisionParameters: generatedParameters } = generatedVisionVectorizer;
-      const parameters = generatedParameters ? {
-        ...generatedParameters,
-        modelVersion: generatedParameters.modelVersion,
-        resourceUri: generatedParameters.resourceUri,
-        authIdentity: convertSearchIndexerDataIdentityToPublic(
-          generatedParameters.authIdentity
-        )
-      } : void 0;
-      const vectorizer = {
-        ...generatedVisionVectorizer,
-        parameters
-      };
-      return vectorizer;
-    },
-    aml: () => {
-      const generatedAMLVectorizer = generatedVectorizer;
-      const vectorizer = {
-        ...generatedAMLVectorizer,
-        amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(
-          generatedAMLVectorizer.amlParameters
-        )
-      };
-      return vectorizer;
-    }
-  };
-  const defaultDeserializer = () => {
-    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.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
-    return generatedVectorizer;
-  };
-  return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
+    if (!encryptionKey) {
+        return undefined;
+    }
+    const result = {
+        keyName: encryptionKey.keyName,
+        keyVersion: encryptionKey.keyVersion,
+        vaultUri: encryptionKey.vaultUrl,
+        identity: encryptionKey.identity,
+        applicationId: encryptionKey.applicationId,
+        applicationSecret: encryptionKey.applicationSecret,
+    };
+    return result;
 }
-function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
-  if (!aMLParameters) {
-    return aMLParameters;
-  }
-  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,
-        authKind: "key"
-      };
-    }
-    case (scoringUri !== void 0 && scoringUri !== null): {
-      return {
-        ...aMLParameters,
-        authKind: "none"
-      };
-    }
-  }
-  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;
+export function generatedIndexToPublicIndex(generatedIndex) {
+    const { charFilters, tokenFilters, scoringProfiles, encryptionKey, analyzers, tokenizers, fields, similarity, vectorSearch, ...rest } = generatedIndex;
     return {
-      ...algorithmConfiguration,
-      parameters: { ...algorithmConfiguration.parameters, metric }
-    };
-  }
-  throw Error("Unsupported algorithm configuration");
-}
-function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
-  if (!vectorSearch) {
-    return vectorSearch;
-  }
-  return {
-    ...vectorSearch,
-    algorithms: vectorSearch.algorithms?.map(
-      generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration
-    ),
-    vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer)
-  };
-}
-function generatedSearchResultToPublicSearchResult(results) {
-  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, additionalProperties } = element;
-    const obj = {
-      text,
-      // The generated code puts document fields in additionalProperties
-      document: additionalProperties ?? {}
-    };
-    return obj;
-  });
-  const result = {
-    results,
-    coverage: searchDocumentsResult.coverage
-  };
-  return result;
-}
-function publicIndexToGeneratedIndex(index) {
-  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
-  };
-}
-function publicSkillsetToGeneratedSkillset(skillset) {
-  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;
-  }
-  return result;
-}
-function publicSynonymMapToGeneratedSynonymMap(synonymMap) {
-  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)
-  };
-}
-function generatedSearchIndexerToPublicSearchIndexer(indexer) {
-  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),
-    cache: convertSearchIndexerCacheToPublic(indexer.cache),
-    schedule: indexer.schedule,
-    isDisabled: indexer.isDisabled
-  };
-}
-function publicDataSourceToGeneratedDataSource(dataSource) {
-  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.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;
-  }
-}
-function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
-  if (!dataChangeDetectionPolicy) {
-    return dataChangeDetectionPolicy;
-  }
-  if (dataChangeDetectionPolicy.odatatype === "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
-    return dataChangeDetectionPolicy;
-  } else {
-    return dataChangeDetectionPolicy;
-  }
-}
-function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
-  if (!dataDeletionDetectionPolicy) {
-    return dataDeletionDetectionPolicy;
-  }
-  return dataDeletionDetectionPolicy;
+        ...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),
+    };
 }
-function getRandomIntegerInclusive(min, max) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  const offset = Math.floor(Math.random() * (max - min + 1));
-  return offset + min;
+export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVectorizer) {
+    if (!generatedVectorizer) {
+        return undefined;
+    }
+    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 = () => {
+        logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
+        return generatedVectorizer;
+    };
+    return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
 }
-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),
-    enableReprocessing: cache.enableReprocessing
-  };
-}
-function convertKnowledgeBaseToPublic(knowledgeBase) {
-  if (!knowledgeBase) {
-    throw new Error("Knowledge base is undefined");
-  }
-  return {
-    ...knowledgeBase,
-    models: (knowledgeBase.models ?? []).map((model) => convertKnowledgeBaseModelToPublic(model)),
-    encryptionKey: convertEncryptionKeyToPublic(knowledgeBase.encryptionKey)
-  };
-}
-function convertKnowledgeBaseToGenerated(knowledgeBase) {
-  if (!knowledgeBase) {
-    return knowledgeBase;
-  }
-  return {
-    ...knowledgeBase,
-    encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey)
-  };
-}
-function convertKnowledgeSourceToPublic(knowledgeSource) {
-  if (!knowledgeSource) {
-    return knowledgeSource;
-  }
-  switch (knowledgeSource.kind) {
-    case "searchIndex": {
-      const { encryptionKey } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
-      };
+export function generatedKnowledgeSourceVectorizerToPublicVectorizer(
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+generatedVectorizer) {
+    if (!generatedVectorizer) {
+        return generatedVectorizer;
     }
-    case "azureBlob": {
-      const { encryptionKey, azureBlobParameters } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        kind: "azureBlob",
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-        azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters)
-      };
+    const knownVectorizerDeserializers = {
+        azureOpenAI: () => {
+            const { parameters } = generatedVectorizer;
+            const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
+            const vectorizer = {
+                ...generatedVectorizer,
+                parameters: { ...parameters, authIdentity },
+            };
+            return vectorizer;
+        },
+    };
+    const defaultDeserializer = () => {
+        logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
+        return generatedVectorizer;
+    };
+    return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
+}
+function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
+    if (!aMLParameters) {
+        return undefined;
     }
-    case "indexedSharePoint": {
-      const { encryptionKey, indexedSharePointParameters } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        kind: "indexedSharePoint",
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-        indexedSharePointParameters: {
-          connectionString: indexedSharePointParameters.connectionString,
-          containerName: indexedSharePointParameters.containerName,
-          createdResources: indexedSharePointParameters.createdResources?.additionalProperties,
-          ingestionParameters: convertKnowledgeIngestionParametersToPublic(
-            indexedSharePointParameters.ingestionParameters
-          ),
-          query: indexedSharePointParameters.query
+    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,
+                apiKey: authenticationKey,
+                authKind: "key",
+            };
+        }
+        case scoringUri !== undefined && scoringUri !== null: {
+            return {
+                ...aMLParameters,
+                authKind: "none",
+            };
         }
-      };
     }
-    case "indexedOneLake": {
-      const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        kind: "indexedOneLake",
+    logger.warning("Unknown AML parameter kind");
+    return aMLParameters;
+}
+export function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
+    if (!generatedAlgorithmConfiguration) {
+        return undefined;
+    }
+    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");
+}
+export function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
+    if (!vectorSearch) {
+        return undefined;
+    }
+    return {
+        ...vectorSearch,
+        algorithms: vectorSearch.algorithms?.map(generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration),
+        vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer),
+    };
+}
+export function generatedSearchResultToPublicSearchResult(results) {
+    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;
+}
+export function generatedSuggestDocumentsResultToPublicSuggestDocumentsResult(searchDocumentsResult) {
+    const results = searchDocumentsResult.results.map((element) => {
+        const { text, additionalProperties } = element;
+        const obj = {
+            text,
+            // The generated code puts document fields in additionalProperties
+            document: additionalProperties ?? {},
+        };
+        return obj;
+    });
+    const result = {
+        results: results,
+        coverage: searchDocumentsResult.coverage,
+    };
+    return result;
+}
+export function publicIndexToGeneratedIndex(index) {
+    const { encryptionKey, tokenFilters, analyzers, fields, similarity } = index;
+    return {
+        ...index,
+        encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
+        tokenFilters: convertTokenFiltersToGenerated(tokenFilters),
+        analyzers: convertAnalyzersToGenerated(analyzers),
+        fields: convertFieldsToGenerated(fields) ?? [],
+        similarity: convertSimilarityToGenerated(similarity),
+    };
+}
+export 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),
-        indexedOneLakeParameters: {
-          fabricWorkspaceId: indexedOneLakeParameters.fabricWorkspaceId,
-          lakehouseId: indexedOneLakeParameters.lakehouseId,
-          ingestionParameters: convertKnowledgeIngestionParametersToPublic(
-            indexedOneLakeParameters.ingestionParameters
-          ),
-          targetPath: indexedOneLakeParameters.targetPath,
-          createdResources: indexedOneLakeParameters.createdResources?.additionalProperties
-        }
-      };
+        indexProjection: indexProjection,
+    };
+}
+export function publicSkillsetToGeneratedSkillset(skillset) {
+    const { cognitiveServicesAccount, encryptionKey } = skillset;
+    return {
+        ...skillset,
+        cognitiveServicesAccount: convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount),
+        encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
+    };
+}
+export function generatedSynonymMapToPublicSynonymMap(synonymMap) {
+    const result = {
+        name: synonymMap.name,
+        encryptionKey: convertEncryptionKeyToPublic(synonymMap.encryptionKey),
+        etag: synonymMap.eTag,
+        synonyms: [],
+    };
+    if (synonymMap.synonyms) {
+        result.synonyms = synonymMap.synonyms;
     }
-    case "remoteSharePoint": {
-      const { encryptionKey } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        kind: "remoteSharePoint",
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
-      };
+    return result;
+}
+export function publicSynonymMapToGeneratedSynonymMap(synonymMap) {
+    const result = {
+        name: synonymMap.name,
+        format: "solr",
+        encryptionKey: convertEncryptionKeyToGenerated(synonymMap.encryptionKey),
+        eTag: synonymMap.etag,
+        synonyms: synonymMap.synonyms,
+    };
+    result.encryptionKey = convertEncryptionKeyToGenerated(synonymMap.encryptionKey);
+    return result;
+}
+export function publicSearchIndexerToGeneratedSearchIndexer(indexer) {
+    return {
+        ...indexer,
+        encryptionKey: convertEncryptionKeyToGenerated(indexer.encryptionKey),
+    };
+}
+export 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,
+        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,
+    };
+}
+export function publicDataSourceToGeneratedDataSource(dataSource) {
+    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),
+    };
+}
+export function generatedDataSourceToPublicDataSource(dataSource) {
+    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),
+    };
+}
+export function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdentity) {
+    if (!searchIndexerDataIdentity) {
+        return undefined;
     }
-    case "web": {
-      const { encryptionKey } = knowledgeSource;
-      return {
-        ...knowledgeSource,
-        kind: "web",
-        encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
-      };
+    if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
+        return searchIndexerDataIdentity;
+    }
+    else {
+        return searchIndexerDataIdentity;
+    }
+}
+export function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
+    if (!dataChangeDetectionPolicy) {
+        return undefined;
+    }
+    if (dataChangeDetectionPolicy.odatatype ===
+        "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
+        return dataChangeDetectionPolicy;
     }
-    default: {
-      logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
-      return void 0;
+    else {
+        return dataChangeDetectionPolicy;
+    }
+}
+export function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
+    if (!dataDeletionDetectionPolicy) {
+        return undefined;
+    }
+    return dataDeletionDetectionPolicy;
+}
+function convertKnowledgeStoreToPublic(knowledgeStore) {
+    if (!knowledgeStore) {
+        return undefined;
+    }
+    return {
+        ...knowledgeStore,
+        identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity),
+    };
+}
+export function convertKnowledgeBaseToPublic(knowledgeBase) {
+    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),
+    };
+}
+export function convertKnowledgeBaseToGenerated(knowledgeBase) {
+    if (!knowledgeBase) {
+        return undefined;
+    }
+    return {
+        ...knowledgeBase,
+        etag: knowledgeBase.etag,
+        encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey),
+    };
+}
+export function convertKnowledgeSourceToPublic(knowledgeSource) {
+    if (!knowledgeSource) {
+        return undefined;
+    }
+    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: {
+            logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
+            return undefined;
+        }
     }
-  }
 }
-function convertKnowledgeSourceToGenerated(knowledgeSource) {
-  if (!knowledgeSource) {
-    return knowledgeSource;
-  }
-  const { encryptionKey } = knowledgeSource;
-  return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToGenerated(encryptionKey) };
+export function convertKnowledgeSourceToGenerated(knowledgeSource) {
+    if (!knowledgeSource) {
+        return undefined;
+    }
+    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 undefined;
+    }
+    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 { 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)
-  };
+    if (!params) {
+        return undefined;
+    }
+    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 {
+    switch (model.kind) {
+        case "azureOpenAI": {
+            const { azureOpenAIParameters, ...rest } = model;
+            return {
+                ...rest,
+                azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters),
+            };
+        }
+        default: {
+            logger.warning("Unknown knowledge base model kind");
+            return model;
+        }
+    }
+}
+function convertAzureOpenAIParametersToPublic(params) {
+    return {
+        ...params,
+        authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity),
+    };
+}
+export 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);
+            }
+        },
+    };
+}
+/**
+ * Converts public IndexDocumentsAction format to generated IndexAction format.
+ * The public API uses `__actionType` with document properties spread at the root,
+ * while the generated API expects `actionType` with document properties in `additionalProperties`.
+ * @internal
+ */
+export function convertPublicActionsToGeneratedActions(actions) {
+    return actions.map((action) => {
+        const { __actionType, ...documentProperties } = action;
+        return {
+            actionType: __actionType,
+            additionalProperties: documentProperties,
+        };
+    });
+}
+// Backward compatibility conversion functions for FacetResult, QueryAnswerResult, and QueryCaptionResult
+// These functions spread additionalProperties onto the top level of the object for backward compatibility
+// with the old API where users could access dynamic properties directly (e.g., facetResult["myProperty"])
+/**
+ * Converts a generated FacetResult to a public FacetResult with additionalProperties spread
+ * onto the object for backward compatibility.
+ * @internal
+ */
+export function convertGeneratedFacetResultToPublic(facetResult) {
+    const { additionalProperties, ...rest } = facetResult;
+    return {
+        ...additionalProperties,
         ...rest,
-        azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters)
-      };
+        additionalProperties,
+    };
+}
+/**
+ * Converts a record of FacetResult arrays from generated to public format.
+ * @internal
+ */
+export function convertGeneratedFacetsToPublic(facets) {
+    if (!facets) {
+        return facets;
     }
-    default: {
-      logger.warning("Unknown knowledge base model kind");
-      return model;
+    const result = {};
+    for (const [key, value] of Object.entries(facets)) {
+        result[key] = value.map(convertGeneratedFacetResultToPublic);
     }
-  }
+    return result;
+}
+/**
+ * Converts a generated QueryAnswerResult to a public QueryAnswerResult with additionalProperties spread
+ * onto the object for backward compatibility.
+ * @internal
+ */
+export function convertGeneratedQueryAnswerResultToPublic(answerResult) {
+    const { additionalProperties, ...rest } = answerResult;
+    return {
+        ...additionalProperties,
+        ...rest,
+        additionalProperties,
+    };
 }
-function convertAzureOpenAIParametersToPublic(params) {
-  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;
+/**
+ * Converts an array of QueryAnswerResult from generated to public format.
+ * @internal
+ */
+export function convertGeneratedAnswersToPublic(answers) {
+    if (!answers) {
+        return answers;
+    }
+    return answers.map(convertGeneratedQueryAnswerResultToPublic);
+}
+/**
+ * Converts a generated QueryCaptionResult to a public QueryCaptionResult with additionalProperties spread
+ * onto the object for backward compatibility.
+ * @internal
+ */
+export function convertGeneratedQueryCaptionResultToPublic(captionResult) {
+    const { additionalProperties, ...rest } = captionResult;
     return {
-      actionType: __actionType,
-      additionalProperties: documentProperties
-    };
-  });
-}
-function convertGeneratedFacetResultToPublic(facetResult) {
-  const { additionalProperties, facets, ...rest } = facetResult;
-  return {
-    ...additionalProperties,
-    ...rest,
-    // Recursively convert nested facets
-    facets: convertGeneratedFacetsToPublic(facets),
-    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);
-}
-export {
-  convertCognitiveServicesAccountToGenerated,
-  convertCognitiveServicesAccountToPublic,
-  convertDataChangeDetectionPolicyToPublic,
-  convertDataDeletionDetectionPolicyToPublic,
-  convertFieldsToGenerated,
-  convertFieldsToPublic,
-  convertGeneratedAnswersToPublic,
-  convertGeneratedCaptionsToPublic,
-  convertGeneratedFacetResultToPublic,
-  convertGeneratedFacetsToPublic,
-  convertGeneratedQueryAnswerResultToPublic,
-  convertGeneratedQueryCaptionResultToPublic,
-  convertKnowledgeBaseToGenerated,
-  convertKnowledgeBaseToPublic,
-  convertKnowledgeSourceToGenerated,
-  convertKnowledgeSourceToPublic,
-  convertPublicActionsToGeneratedActions,
-  convertSearchIndexerCacheToPublic,
-  convertSearchIndexerDataIdentityToPublic,
-  convertSimilarityToGenerated,
-  convertSimilarityToPublic,
-  convertSkillsToPublic,
-  convertTokenFiltersToGenerated,
-  defaultServiceVersion,
-  generatedDataSourceToPublicDataSource,
-  generatedIndexToPublicIndex,
-  generatedKnowledgeSourceVectorizerToPublicVectorizer,
-  generatedSearchIndexerToPublicSearchIndexer,
-  generatedSearchResultToPublicSearchResult,
-  generatedSkillsetToPublicSkillset,
-  generatedSuggestDocumentsResultToPublicSuggestDocumentsResult,
-  generatedSynonymMapToPublicSynonymMap,
-  generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration,
-  generatedVectorSearchToPublicVectorSearch,
-  generatedVectorSearchVectorizerToPublicVectorizer,
-  getRandomIntegerInclusive,
-  mapPagedAsyncIterable,
-  publicDataSourceToGeneratedDataSource,
-  publicIndexToGeneratedIndex,
-  publicSearchIndexerToGeneratedSearchIndexer,
-  publicSkillsetToGeneratedSkillset,
-  publicSynonymMapToGeneratedSynonymMap
-};
+        ...additionalProperties,
+        ...rest,
+        additionalProperties,
+    };
+}
+/**
+ * Converts an array of QueryCaptionResult from generated to public format.
+ * @internal
+ */
+export function convertGeneratedCaptionsToPublic(captions) {
+    if (!captions) {
+        return captions;
+    }
+    return captions.map(convertGeneratedQueryCaptionResultToPublic);
+}
+//# sourceMappingURL=serviceUtils.js.map