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

package/dist/esm/serviceUtils.js

@@ -0,0 +1,699 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { logger } from "./logger.js";
+import { isComplexField } from "./serviceModels.js";
+export const defaultServiceVersion = "2025-08-01-Preview";
+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,
+};
+export function convertSkillsToPublic(skills) {
+    if (!skills) {
+        return skills;
+    }
+    // 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 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.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,
+                    flags: analyzer.flags ? analyzer.flags.join("|") : undefined,
+                });
+                break;
+            case "#Microsoft.Azure.Search.CustomAnalyzer":
+                result.push({
+                    ...analyzer,
+                    tokenizerName: 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;
+}
+export 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;
+        }
+    });
+}
+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,
+                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;
+}
+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;
+}
+export function convertSimilarityToGenerated(similarity) {
+    if (!similarity) {
+        return similarity;
+    }
+    return similarity;
+}
+export function convertSimilarityToPublic(similarity) {
+    if (!similarity) {
+        return similarity;
+    }
+    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;
+}
+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;
+}
+export 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),
+    };
+}
+export 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.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.warning("Unknown AML parameter kind");
+    return aMLParameters;
+}
+export 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");
+}
+export function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
+    if (!vectorSearch) {
+        return vectorSearch;
+    }
+    return {
+        ...vectorSearch,
+        algorithms: vectorSearch.algorithms?.map(generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration),
+        vectorizers: vectorSearch.vectorizers?.map(generatedVectorSearchVectorizerToPublicVectorizer),
+    };
+}
+export 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;
+}
+export 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,
+    };
+    return result;
+}
+export 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),
+    };
+}
+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),
+        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.split("\n");
+    }
+    return result;
+}
+export 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;
+}
+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,
+    };
+    const parameters = {
+        ...indexer.parameters,
+        configuration,
+    };
+    return {
+        ...indexer,
+        parameters,
+        encryptionKey: convertEncryptionKeyToPublic(indexer.encryptionKey),
+        cache: convertSearchIndexerCacheToPublic(indexer.cache),
+    };
+}
+export 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),
+    };
+}
+export 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),
+    };
+}
+export function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdentity) {
+    if (!searchIndexerDataIdentity) {
+        return searchIndexerDataIdentity;
+    }
+    if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
+        return searchIndexerDataIdentity;
+    }
+    else {
+        return searchIndexerDataIdentity;
+    }
+}
+export function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
+    if (!dataChangeDetectionPolicy) {
+        return dataChangeDetectionPolicy;
+    }
+    if (dataChangeDetectionPolicy.odatatype ===
+        "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
+        return dataChangeDetectionPolicy;
+    }
+    else {
+        return dataChangeDetectionPolicy;
+    }
+}
+export function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
+    if (!dataDeletionDetectionPolicy) {
+        return dataDeletionDetectionPolicy;
+    }
+    return dataDeletionDetectionPolicy;
+}
+export 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;
+}
+function convertKnowledgeStoreToPublic(knowledgeStore) {
+    if (!knowledgeStore) {
+        return knowledgeStore;
+    }
+    return {
+        ...knowledgeStore,
+        identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity),
+    };
+}
+export function convertSearchIndexerCacheToPublic(cache) {
+    if (!cache) {
+        return cache;
+    }
+    return {
+        ...cache,
+        identity: convertSearchIndexerDataIdentityToPublic(cache.identity),
+    };
+}
+export function convertKnowledgeAgentToPublic(knowledgeAgent) {
+    if (!knowledgeAgent) {
+        return knowledgeAgent;
+    }
+    return {
+        ...knowledgeAgent,
+        models: knowledgeAgent.models.map((model) => convertKnowledgeAgentModelToPublic(model)),
+        encryptionKey: convertEncryptionKeyToPublic(knowledgeAgent.encryptionKey),
+    };
+}
+export function convertKnowledgeAgentToGenerated(knowledgeAgent) {
+    if (!knowledgeAgent) {
+        return knowledgeAgent;
+    }
+    return {
+        ...knowledgeAgent,
+        encryptionKey: convertEncryptionKeyToGenerated(knowledgeAgent.encryptionKey),
+    };
+}
+export 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),
+            };
+        }
+    }
+}
+export function convertKnowledgeSourceToGenerated(knowledgeSource) {
+    if (!knowledgeSource) {
+        return knowledgeSource;
+    }
+    const { encryptionKey } = knowledgeSource;
+    return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToGenerated(encryptionKey) };
+}
+function convertAzureBlobKnowledgeSourceParametersToPublic(params) {
+    if (!params) {
+        return params;
+    }
+    const { embeddingModel, identity, chatCompletionModel, ...rest } = params;
+    return {
+        ...rest,
+        embeddingModel: !embeddingModel
+            ? embeddingModel
+            : generatedVectorSearchVectorizerToPublicVectorizer(embeddingModel),
+        identity: convertSearchIndexerDataIdentityToPublic(identity),
+        chatCompletionModel: !chatCompletionModel
+            ? chatCompletionModel
+            : convertKnowledgeAgentModelToPublic(chatCompletionModel),
+    };
+}
+function convertKnowledgeAgentModelToPublic(model) {
+    switch (model.kind) {
+        case "azureOpenAI": {
+            const { azureOpenAIParameters, ...rest } = model;
+            return {
+                ...rest,
+                azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters),
+            };
+        }
+        default: {
+            logger.warning("Unknown knowledge agent model kind");
+            return model;
+        }
+    }
+}
+function convertAzureOpenAIParametersToPublic(params) {
+    return { ...params, authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity) };
+}
+//# sourceMappingURL=serviceUtils.js.map