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

package/dist/browser/serviceUtils.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { logger } from "./logger.js";
 import { isComplexField } from "./serviceModels.js";
-export const defaultServiceVersion = "2025-11-01-Preview";
+export const defaultServiceVersion = "2026-04-01";
 const knownSkills = {
     "#Microsoft.Skills.Custom.ChatCompletionSkill": true,
     "#Microsoft.Skills.Custom.WebApiSkill": true,
@@ -31,7 +31,7 @@ const knownSkills = {
 };
 export function convertSkillsToPublic(skills) {
     if (!skills) {
-        return skills;
+        return [];
     }
     // This validation has already GAed
     return skills.filter((skill) => knownSkills[skill.odatatype]);
@@ -54,7 +54,7 @@ export function convertCognitiveServicesAccountToGenerated(cognitiveServicesAcco
 }
 export function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount) {
     if (!cognitiveServicesAccount) {
-        return cognitiveServicesAccount;
+        return undefined;
     }
     const deserializers = {
         "#Microsoft.Azure.Search.DefaultCognitiveServices": () => {
@@ -70,7 +70,7 @@ export function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount
             const { identity, ...restParams } = cognitiveServicesAccount;
             return {
                 ...restParams,
-                identity: convertSearchIndexerDataIdentityToPublic(identity ?? undefined),
+                identity: convertSearchIndexerDataIdentityToPublic(identity),
             };
         },
     };
@@ -102,15 +102,12 @@ function convertAnalyzersToGenerated(analyzers) {
                 result.push(analyzer);
                 break;
             case "#Microsoft.Azure.Search.PatternAnalyzer":
-                result.push({
-                    ...analyzer,
-                    flags: analyzer.flags ? analyzer.flags.join("|") : undefined,
-                });
+                result.push(analyzer);
                 break;
             case "#Microsoft.Azure.Search.CustomAnalyzer":
                 result.push({
                     ...analyzer,
-                    tokenizerName: analyzer.tokenizerName,
+                    tokenizer: analyzer.tokenizerName,
                 });
                 break;
         }
@@ -119,7 +116,7 @@ function convertAnalyzersToGenerated(analyzers) {
 }
 function convertAnalyzersToPublic(analyzers) {
     if (!analyzers) {
-        return analyzers;
+        return undefined;
     }
     const result = [];
     for (const analyzer of analyzers) {
@@ -133,9 +130,6 @@ function convertAnalyzersToPublic(analyzers) {
             case "#Microsoft.Azure.Search.PatternAnalyzer":
                 result.push({
                     ...analyzer,
-                    flags: analyzer.flags
-                        ? analyzer.flags.split("|")
-                        : undefined,
                 });
                 break;
             case "#Microsoft.Azure.Search.CustomAnalyzer":
@@ -147,7 +141,7 @@ function convertAnalyzersToPublic(analyzers) {
 }
 export function convertFieldsToPublic(fields) {
     if (!fields) {
-        return fields;
+        return undefined;
     }
     return fields.map((field) => {
         if (field.type === "Collection(Edm.ComplexType)" || field.type === "Edm.ComplexType") {
@@ -160,17 +154,13 @@ export function convertFieldsToPublic(fields) {
         }
         else {
             const type = field.type;
-            const synonymMapNames = field.synonymMaps;
-            const { retrievable, analyzer, searchAnalyzer, indexAnalyzer, normalizer, ...restField } = field;
+            const synonymMapNames = field.synonymMapNames;
+            const { retrievable, ...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;
@@ -197,50 +187,22 @@ export function convertFieldsToGenerated(fields) {
                 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,
+                analyzerName: field.analyzerName,
+                searchAnalyzerName: field.searchAnalyzerName,
+                indexAnalyzerName: field.indexAnalyzerName,
+                synonymMapNames: field.synonymMapNames,
+                normalizerName: 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;
+        return undefined;
     }
     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);
-        }
+        result.push(tokenizer);
     }
     return result;
 }
@@ -252,7 +214,7 @@ export function convertSimilarityToGenerated(similarity) {
 }
 export function convertSimilarityToPublic(similarity) {
     if (!similarity) {
-        return similarity;
+        return undefined;
     }
     if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
         return similarity;
@@ -263,36 +225,30 @@ export function convertSimilarityToPublic(similarity) {
 }
 function convertEncryptionKeyToPublic(encryptionKey) {
     if (!encryptionKey) {
-        return encryptionKey;
+        return undefined;
     }
     const result = {
         keyName: encryptionKey.keyName,
         keyVersion: encryptionKey.keyVersion,
         vaultUrl: encryptionKey.vaultUri,
         identity: convertSearchIndexerDataIdentityToPublic(encryptionKey.identity),
+        applicationId: encryptionKey.applicationId,
+        applicationSecret: encryptionKey.applicationSecret,
     };
-    if (encryptionKey.accessCredentials) {
-        result.applicationId = encryptionKey.accessCredentials.applicationId;
-        result.applicationSecret = encryptionKey.accessCredentials.applicationSecret;
-    }
     return result;
 }
 function convertEncryptionKeyToGenerated(encryptionKey) {
     if (!encryptionKey) {
-        return encryptionKey;
+        return undefined;
     }
     const result = {
         keyName: encryptionKey.keyName,
         keyVersion: encryptionKey.keyVersion,
         vaultUri: encryptionKey.vaultUrl,
         identity: encryptionKey.identity,
+        applicationId: encryptionKey.applicationId,
+        applicationSecret: encryptionKey.applicationSecret,
     };
-    if (encryptionKey.applicationId) {
-        result.accessCredentials = {
-            applicationId: encryptionKey.applicationId,
-            applicationSecret: encryptionKey.applicationSecret,
-        };
-    }
     return result;
 }
 export function generatedIndexToPublicIndex(generatedIndex) {
@@ -312,7 +268,7 @@ export function generatedIndexToPublicIndex(generatedIndex) {
 }
 export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVectorizer) {
     if (!generatedVectorizer) {
-        return generatedVectorizer;
+        return undefined;
     }
     const knownVectorizerDeserializers = {
         azureOpenAI: () => {
@@ -325,28 +281,11 @@ export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVecto
             return vectorizer;
         },
         customWebApi: () => {
-            const { parameters } = generatedVectorizer;
-            const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
+            const { webApiParameters } = generatedVectorizer;
+            const authIdentity = convertSearchIndexerDataIdentityToPublic(webApiParameters?.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,
+                parameters: { ...webApiParameters, authIdentity },
             };
             return vectorizer;
         },
@@ -354,7 +293,7 @@ export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVecto
             const generatedAMLVectorizer = generatedVectorizer;
             const vectorizer = {
                 ...generatedAMLVectorizer,
-                amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(generatedAMLVectorizer.aMLParameters),
+                amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(generatedAMLVectorizer.amlParameters),
             };
             return vectorizer;
         },
@@ -365,7 +304,9 @@ export function generatedVectorSearchVectorizerToPublicVectorizer(generatedVecto
     };
     return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
 }
-export function generatedKnowledgeSourceVectorizerToPublicVectorizer(generatedVectorizer) {
+export function generatedKnowledgeSourceVectorizerToPublicVectorizer(
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+generatedVectorizer) {
     if (!generatedVectorizer) {
         return generatedVectorizer;
     }
@@ -388,7 +329,7 @@ export function generatedKnowledgeSourceVectorizerToPublicVectorizer(generatedVe
 }
 function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
     if (!aMLParameters) {
-        return aMLParameters;
+        return undefined;
     }
     const { resourceId, authenticationKey, scoringUri } = aMLParameters;
     // Sensitive to case order
@@ -402,6 +343,7 @@ function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLe
         case authenticationKey !== undefined && authenticationKey !== null: {
             return {
                 ...aMLParameters,
+                apiKey: authenticationKey,
                 authKind: "key",
             };
         }
@@ -417,7 +359,7 @@ function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLe
 }
 export function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
     if (!generatedAlgorithmConfiguration) {
-        return generatedAlgorithmConfiguration;
+        return undefined;
     }
     if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
         const algorithmConfiguration = generatedAlgorithmConfiguration;
@@ -431,7 +373,7 @@ export function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchA
 }
 export function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
     if (!vectorSearch) {
-        return vectorSearch;
+        return undefined;
     }
     return {
         ...vectorSearch,
@@ -441,15 +383,16 @@ export function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
 }
 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 { score, highlights, rerankerScore, rerankerBoostedScore, captions, documentDebugInfo, additionalProperties, } = result;
         const obj = {
             score,
             highlights,
             rerankerScore,
             rerankerBoostedScore,
-            captions,
+            captions: convertGeneratedCaptionsToPublic(captions),
             documentDebugInfo,
-            document: restProps,
+            // The generated code puts document fields in additionalProperties
+            document: additionalProperties ?? {},
         };
         return obj;
     });
@@ -457,10 +400,11 @@ export function generatedSearchResultToPublicSearchResult(results) {
 }
 export function generatedSuggestDocumentsResultToPublicSuggestDocumentsResult(searchDocumentsResult) {
     const results = searchDocumentsResult.results.map((element) => {
-        const { _text, ...restProps } = element;
+        const { text, additionalProperties } = element;
         const obj = {
-            text: _text,
-            document: restProps,
+            text,
+            // The generated code puts document fields in additionalProperties
+            document: additionalProperties ?? {},
         };
         return obj;
     });
@@ -471,13 +415,12 @@ export function generatedSuggestDocumentsResultToPublicSuggestDocumentsResult(se
     return result;
 }
 export function publicIndexToGeneratedIndex(index) {
-    const { encryptionKey, tokenFilters, analyzers, tokenizers, fields, similarity } = index;
+    const { encryptionKey, tokenFilters, analyzers, fields, similarity } = index;
     return {
         ...index,
         encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
         tokenFilters: convertTokenFiltersToGenerated(tokenFilters),
         analyzers: convertAnalyzersToGenerated(analyzers),
-        tokenizers: convertTokenizersToGenerated(tokenizers),
         fields: convertFieldsToGenerated(fields) ?? [],
         similarity: convertSimilarityToGenerated(similarity),
     };
@@ -505,11 +448,11 @@ export function generatedSynonymMapToPublicSynonymMap(synonymMap) {
     const result = {
         name: synonymMap.name,
         encryptionKey: convertEncryptionKeyToPublic(synonymMap.encryptionKey),
-        etag: synonymMap.etag,
+        etag: synonymMap.eTag,
         synonyms: [],
     };
     if (synonymMap.synonyms) {
-        result.synonyms = synonymMap.synonyms.split("\n");
+        result.synonyms = synonymMap.synonyms;
     }
     return result;
 }
@@ -518,8 +461,8 @@ export function publicSynonymMapToGeneratedSynonymMap(synonymMap) {
         name: synonymMap.name,
         format: "solr",
         encryptionKey: convertEncryptionKeyToGenerated(synonymMap.encryptionKey),
-        etag: synonymMap.etag,
-        synonyms: synonymMap.synonyms.join("\n"),
+        eTag: synonymMap.etag,
+        synonyms: synonymMap.synonyms,
     };
     result.encryptionKey = convertEncryptionKeyToGenerated(synonymMap.encryptionKey);
     return result;
@@ -540,16 +483,22 @@ export function generatedSearchIndexerToPublicSearchIndexer(indexer) {
         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),
-        cache: convertSearchIndexerCacheToPublic(indexer.cache),
+        schedule: indexer.schedule,
+        isDisabled: indexer.isDisabled,
     };
 }
 export function publicDataSourceToGeneratedDataSource(dataSource) {
@@ -557,12 +506,10 @@ export function publicDataSourceToGeneratedDataSource(dataSource) {
         name: dataSource.name,
         description: dataSource.description,
         type: dataSource.type,
-        credentials: {
-            connectionString: dataSource.connectionString,
-        },
+        connectionString: dataSource.connectionString,
         container: dataSource.container,
         identity: dataSource.identity,
-        etag: dataSource.etag,
+        eTag: dataSource.etag,
         dataChangeDetectionPolicy: dataSource.dataChangeDetectionPolicy,
         dataDeletionDetectionPolicy: dataSource.dataDeletionDetectionPolicy,
         encryptionKey: convertEncryptionKeyToGenerated(dataSource.encryptionKey),
@@ -571,12 +518,12 @@ export function publicDataSourceToGeneratedDataSource(dataSource) {
 export function generatedDataSourceToPublicDataSource(dataSource) {
     return {
         name: dataSource.name,
-        description: dataSource.name,
+        description: dataSource.description,
         type: dataSource.type,
-        connectionString: dataSource.credentials.connectionString,
+        connectionString: dataSource.connectionString,
         container: dataSource.container,
         identity: convertSearchIndexerDataIdentityToPublic(dataSource.identity),
-        etag: dataSource.etag,
+        etag: dataSource.eTag,
         dataChangeDetectionPolicy: convertDataChangeDetectionPolicyToPublic(dataSource.dataChangeDetectionPolicy),
         dataDeletionDetectionPolicy: convertDataDeletionDetectionPolicyToPublic(dataSource.dataDeletionDetectionPolicy),
         encryptionKey: convertEncryptionKeyToPublic(dataSource.encryptionKey),
@@ -584,7 +531,7 @@ export function generatedDataSourceToPublicDataSource(dataSource) {
 }
 export function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdentity) {
     if (!searchIndexerDataIdentity) {
-        return searchIndexerDataIdentity;
+        return undefined;
     }
     if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
         return searchIndexerDataIdentity;
@@ -595,7 +542,7 @@ export function convertSearchIndexerDataIdentityToPublic(searchIndexerDataIdenti
 }
 export function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
     if (!dataChangeDetectionPolicy) {
-        return dataChangeDetectionPolicy;
+        return undefined;
     }
     if (dataChangeDetectionPolicy.odatatype ===
         "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
@@ -607,119 +554,103 @@ export function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPoli
 }
 export function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
     if (!dataDeletionDetectionPolicy) {
-        return dataDeletionDetectionPolicy;
+        return undefined;
     }
     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 undefined;
     }
     return {
         ...knowledgeStore,
         identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity),
     };
 }
-export function convertSearchIndexerCacheToPublic(cache) {
-    if (!cache) {
-        return cache;
-    }
-    return {
-        ...cache,
-        identity: convertSearchIndexerDataIdentityToPublic(cache.identity),
-    };
-}
 export function convertKnowledgeBaseToPublic(knowledgeBase) {
     if (!knowledgeBase) {
-        return knowledgeBase;
+        throw new Error("Knowledge base is undefined");
     }
     return {
         ...knowledgeBase,
-        models: knowledgeBase.models.map((model) => convertKnowledgeBaseModelToPublic(model)),
+        etag: knowledgeBase.etag,
+        models: (knowledgeBase.models ?? []).map((model) => convertKnowledgeBaseModelToPublic(model)),
         encryptionKey: convertEncryptionKeyToPublic(knowledgeBase.encryptionKey),
     };
 }
 export function convertKnowledgeBaseToGenerated(knowledgeBase) {
     if (!knowledgeBase) {
-        return knowledgeBase;
+        return undefined;
     }
     return {
         ...knowledgeBase,
+        etag: knowledgeBase.etag,
         encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey),
     };
 }
 export function convertKnowledgeSourceToPublic(knowledgeSource) {
     if (!knowledgeSource) {
-        return knowledgeSource;
+        return undefined;
     }
     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;
+        case "azureBlob": {
+            const { encryptionKey, azureBlobParameters } = knowledgeSource;
             return {
                 ...knowledgeSource,
+                kind: "azureBlob",
                 encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
-                indexedSharePointParameters: {
-                    ...indexedSharePointParameters,
-                    ingestionParameters: convertKnowledgeIngestionParametersToPublic(indexedSharePointParameters.ingestionParameters),
-                },
+                azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters),
             };
         }
         case "indexedOneLake": {
             const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
             return {
                 ...knowledgeSource,
+                kind: "indexedOneLake",
                 encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
                 indexedOneLakeParameters: {
-                    ...indexedOneLakeParameters,
+                    fabricWorkspaceId: indexedOneLakeParameters.fabricWorkspaceId,
+                    lakehouseId: indexedOneLakeParameters.lakehouseId,
                     ingestionParameters: convertKnowledgeIngestionParametersToPublic(indexedOneLakeParameters.ingestionParameters),
+                    targetPath: indexedOneLakeParameters.targetPath,
+                    createdResources: indexedOneLakeParameters.createdResources?.additionalProperties,
                 },
             };
         }
-        case "remoteSharePoint": {
+        case "web": {
             const { encryptionKey } = knowledgeSource;
             return {
                 ...knowledgeSource,
+                kind: "web",
                 encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
             };
         }
-        case "web": {
-            const { encryptionKey } = knowledgeSource;
-            return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToPublic(encryptionKey) };
+        default: {
+            logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
+            return undefined;
         }
     }
 }
 export function convertKnowledgeSourceToGenerated(knowledgeSource) {
     if (!knowledgeSource) {
-        return knowledgeSource;
+        return undefined;
     }
     const { encryptionKey } = knowledgeSource;
-    return { ...knowledgeSource, encryptionKey: convertEncryptionKeyToGenerated(encryptionKey) };
+    return {
+        ...knowledgeSource,
+        encryptionKey: convertEncryptionKeyToGenerated(encryptionKey),
+    };
 }
 function convertKnowledgeIngestionParametersToPublic(params) {
     if (!params) {
-        return params;
+        return undefined;
     }
     const { embeddingModel, chatCompletionModel, identity, ...rest } = params;
     return {
@@ -735,19 +666,17 @@ function convertKnowledgeIngestionParametersToPublic(params) {
 }
 function convertAzureBlobKnowledgeSourceParametersToPublic(params) {
     if (!params) {
-        return params;
+        return undefined;
     }
-    const { ingestionParameters, ...rest } = params;
-    if (!ingestionParameters) {
-        return { ...rest };
-    }
-    const { embeddingModel, chatCompletionModel, identity } = ingestionParameters;
+    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),
@@ -769,6 +698,120 @@ function convertKnowledgeBaseModelToPublic(model) {
     }
 }
 function convertAzureOpenAIParametersToPublic(params) {
-    return { ...params, authIdentity: convertSearchIndexerDataIdentityToPublic(params.authIdentity) };
+    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,
+        additionalProperties,
+    };
+}
+/**
+ * Converts a record of FacetResult arrays from generated to public format.
+ * @internal
+ */
+export function convertGeneratedFacetsToPublic(facets) {
+    if (!facets) {
+        return facets;
+    }
+    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,
+    };
+}
+/**
+ * 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 {
+        ...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