@azure/search-documents
Version:
Azure client library to use AI Search for node.js and browser.
913 lines (912 loc) • 31.8 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var serviceUtils_exports = {};
__export(serviceUtils_exports, {
convertCognitiveServicesAccountToGenerated: () => convertCognitiveServicesAccountToGenerated,
convertCognitiveServicesAccountToPublic: () => convertCognitiveServicesAccountToPublic,
convertDataChangeDetectionPolicyToPublic: () => convertDataChangeDetectionPolicyToPublic,
convertDataDeletionDetectionPolicyToPublic: () => convertDataDeletionDetectionPolicyToPublic,
convertFieldsToGenerated: () => convertFieldsToGenerated,
convertFieldsToPublic: () => convertFieldsToPublic,
convertGeneratedAnswersToPublic: () => convertGeneratedAnswersToPublic,
convertGeneratedCaptionsToPublic: () => convertGeneratedCaptionsToPublic,
convertGeneratedFacetResultToPublic: () => convertGeneratedFacetResultToPublic,
convertGeneratedFacetsToPublic: () => convertGeneratedFacetsToPublic,
convertGeneratedQueryAnswerResultToPublic: () => convertGeneratedQueryAnswerResultToPublic,
convertGeneratedQueryCaptionResultToPublic: () => convertGeneratedQueryCaptionResultToPublic,
convertKnowledgeBaseToGenerated: () => convertKnowledgeBaseToGenerated,
convertKnowledgeBaseToPublic: () => convertKnowledgeBaseToPublic,
convertKnowledgeSourceToGenerated: () => convertKnowledgeSourceToGenerated,
convertKnowledgeSourceToPublic: () => convertKnowledgeSourceToPublic,
convertPublicActionsToGeneratedActions: () => convertPublicActionsToGeneratedActions,
convertSearchIndexerDataIdentityToPublic: () => convertSearchIndexerDataIdentityToPublic,
convertSimilarityToGenerated: () => convertSimilarityToGenerated,
convertSimilarityToPublic: () => convertSimilarityToPublic,
convertSkillsToPublic: () => convertSkillsToPublic,
convertTokenFiltersToGenerated: () => convertTokenFiltersToGenerated,
defaultServiceVersion: () => defaultServiceVersion,
generatedDataSourceToPublicDataSource: () => generatedDataSourceToPublicDataSource,
generatedIndexToPublicIndex: () => generatedIndexToPublicIndex,
generatedKnowledgeSourceVectorizerToPublicVectorizer: () => generatedKnowledgeSourceVectorizerToPublicVectorizer,
generatedSearchIndexerToPublicSearchIndexer: () => generatedSearchIndexerToPublicSearchIndexer,
generatedSearchResultToPublicSearchResult: () => generatedSearchResultToPublicSearchResult,
generatedSkillsetToPublicSkillset: () => generatedSkillsetToPublicSkillset,
generatedSuggestDocumentsResultToPublicSuggestDocumentsResult: () => generatedSuggestDocumentsResultToPublicSuggestDocumentsResult,
generatedSynonymMapToPublicSynonymMap: () => generatedSynonymMapToPublicSynonymMap,
generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration: () => generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration,
generatedVectorSearchToPublicVectorSearch: () => generatedVectorSearchToPublicVectorSearch,
generatedVectorSearchVectorizerToPublicVectorizer: () => generatedVectorSearchVectorizerToPublicVectorizer,
mapPagedAsyncIterable: () => mapPagedAsyncIterable,
publicDataSourceToGeneratedDataSource: () => publicDataSourceToGeneratedDataSource,
publicIndexToGeneratedIndex: () => publicIndexToGeneratedIndex,
publicSearchIndexerToGeneratedSearchIndexer: () => publicSearchIndexerToGeneratedSearchIndexer,
publicSkillsetToGeneratedSkillset: () => publicSkillsetToGeneratedSkillset,
publicSynonymMapToGeneratedSynonymMap: () => publicSynonymMapToGeneratedSynonymMap
});
module.exports = __toCommonJS(serviceUtils_exports);
var import_logger = require("./logger.js");
var import_serviceModels = require("./serviceModels.js");
const defaultServiceVersion = "2026-04-01";
const knownSkills = {
"#Microsoft.Skills.Custom.ChatCompletionSkill": true,
"#Microsoft.Skills.Custom.WebApiSkill": true,
"#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill": true,
"#Microsoft.Skills.Text.CustomEntityLookupSkill": true,
"#Microsoft.Skills.Text.EntityRecognitionSkill": true,
"#Microsoft.Skills.Text.KeyPhraseExtractionSkill": true,
"#Microsoft.Skills.Text.LanguageDetectionSkill": true,
"#Microsoft.Skills.Text.MergeSkill": true,
"#Microsoft.Skills.Text.PIIDetectionSkill": true,
"#Microsoft.Skills.Text.SentimentSkill": true,
"#Microsoft.Skills.Text.SplitSkill": true,
"#Microsoft.Skills.Text.TranslationSkill": true,
"#Microsoft.Skills.Text.V3.EntityLinkingSkill": true,
"#Microsoft.Skills.Text.V3.EntityRecognitionSkill": true,
"#Microsoft.Skills.Text.V3.SentimentSkill": true,
"#Microsoft.Skills.Util.ConditionalSkill": true,
"#Microsoft.Skills.Util.DocumentExtractionSkill": true,
"#Microsoft.Skills.Util.ShaperSkill": true,
"#Microsoft.Skills.Vision.ImageAnalysisSkill": true,
"#Microsoft.Skills.Vision.OcrSkill": true,
"#Microsoft.Skills.Custom.AmlSkill": true,
"#Microsoft.Skills.Vision.VectorizeSkill": true,
"#Microsoft.Skills.Util.DocumentIntelligenceLayoutSkill": true,
"#Microsoft.Skills.Util.ContentUnderstandingSkill": true
};
function convertSkillsToPublic(skills) {
if (!skills) {
return [];
}
return skills.filter((skill) => knownSkills[skill.odatatype]);
}
function convertCognitiveServicesAccountToGenerated(cognitiveServicesAccount) {
if (!cognitiveServicesAccount) {
return cognitiveServicesAccount;
}
switch (cognitiveServicesAccount.odatatype) {
case "#Microsoft.Azure.Search.AIServicesByIdentity":
case "#Microsoft.Azure.Search.DefaultCognitiveServices":
case "#Microsoft.Azure.Search.CognitiveServicesByKey":
case "#Microsoft.Azure.Search.AIServicesByKey":
return cognitiveServicesAccount;
default: {
import_logger.logger.warning(
`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`
);
return cognitiveServicesAccount;
}
}
}
function convertCognitiveServicesAccountToPublic(cognitiveServicesAccount) {
if (!cognitiveServicesAccount) {
return void 0;
}
const deserializers = {
"#Microsoft.Azure.Search.DefaultCognitiveServices": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.CognitiveServicesByKey": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.AIServicesByKey": () => {
return cognitiveServicesAccount;
},
"#Microsoft.Azure.Search.AIServicesByIdentity": () => {
const { identity, ...restParams } = cognitiveServicesAccount;
return {
...restParams,
identity: convertSearchIndexerDataIdentityToPublic(identity)
};
}
};
const defaultDeserializer = () => {
import_logger.logger.warning(
`Unsupported Cognitive Services account odatatype: ${cognitiveServicesAccount.odatatype}`
);
return cognitiveServicesAccount;
};
return (deserializers[cognitiveServicesAccount.odatatype] ?? defaultDeserializer)();
}
function convertTokenFiltersToGenerated(tokenFilters) {
if (!tokenFilters) {
return tokenFilters;
}
const result = [];
for (const filter of tokenFilters) {
result.push(filter);
}
return result;
}
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;
}
function convertAnalyzersToPublic(analyzers) {
if (!analyzers) {
return void 0;
}
const result = [];
for (const analyzer of analyzers) {
switch (analyzer.odatatype) {
case "#Microsoft.Azure.Search.StandardAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.StopAnalyzer":
result.push(analyzer);
break;
case "#Microsoft.Azure.Search.PatternAnalyzer":
result.push({
...analyzer
});
break;
case "#Microsoft.Azure.Search.CustomAnalyzer":
result.push(analyzer);
break;
}
}
return result;
}
function convertFieldsToPublic(fields) {
if (!fields) {
return void 0;
}
return fields.map((field) => {
if (field.type === "Collection(Edm.ComplexType)" || field.type === "Edm.ComplexType") {
const result = {
name: field.name,
type: field.type,
fields: convertFieldsToPublic(field.fields)
};
return result;
} else {
const type = field.type;
const synonymMapNames = field.synonymMapNames;
const { retrievable, ...restField } = field;
const hidden = typeof retrievable === "boolean" ? !retrievable : retrievable;
const result = {
...restField,
type,
hidden,
synonymMapNames
};
return result;
}
});
}
function convertFieldsToGenerated(fields) {
return fields?.map((field) => {
if ((0, import_serviceModels.isComplexField)(field)) {
return {
name: field.name,
type: field.type,
fields: convertFieldsToGenerated(field.fields)
};
} else {
const { hidden, ...restField } = field;
const retrievable = typeof hidden === "boolean" ? !hidden : hidden;
return {
...restField,
retrievable,
// modify API defaults to use less storage for simple types
searchable: field.searchable ?? false,
filterable: field.filterable ?? false,
facetable: field.facetable ?? false,
sortable: field.sortable ?? false,
analyzerName: field.analyzerName,
searchAnalyzerName: field.searchAnalyzerName,
indexAnalyzerName: field.indexAnalyzerName,
synonymMapNames: field.synonymMapNames,
normalizerName: field.normalizerName
};
}
});
}
function convertTokenizersToPublic(tokenizers) {
if (!tokenizers) {
return void 0;
}
const result = [];
for (const tokenizer of tokenizers) {
result.push(tokenizer);
}
return result;
}
function convertSimilarityToGenerated(similarity) {
if (!similarity) {
return similarity;
}
return similarity;
}
function convertSimilarityToPublic(similarity) {
if (!similarity) {
return void 0;
}
if (similarity.odatatype === "#Microsoft.Azure.Search.ClassicSimilarity") {
return similarity;
} else {
return similarity;
}
}
function convertEncryptionKeyToPublic(encryptionKey) {
if (!encryptionKey) {
return void 0;
}
const result = {
keyName: encryptionKey.keyName,
keyVersion: encryptionKey.keyVersion,
vaultUrl: encryptionKey.vaultUri,
identity: convertSearchIndexerDataIdentityToPublic(encryptionKey.identity),
applicationId: encryptionKey.applicationId,
applicationSecret: encryptionKey.applicationSecret
};
return result;
}
function convertEncryptionKeyToGenerated(encryptionKey) {
if (!encryptionKey) {
return void 0;
}
const result = {
keyName: encryptionKey.keyName,
keyVersion: encryptionKey.keyVersion,
vaultUri: encryptionKey.vaultUrl,
identity: encryptionKey.identity,
applicationId: encryptionKey.applicationId,
applicationSecret: encryptionKey.applicationSecret
};
return result;
}
function generatedIndexToPublicIndex(generatedIndex) {
const {
charFilters,
tokenFilters,
scoringProfiles,
encryptionKey,
analyzers,
tokenizers,
fields,
similarity,
vectorSearch,
...rest
} = generatedIndex;
return {
...rest,
scoringProfiles,
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 void 0;
}
const knownVectorizerDeserializers = {
azureOpenAI: () => {
const { parameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...parameters, authIdentity }
};
return vectorizer;
},
customWebApi: () => {
const { webApiParameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(webApiParameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...webApiParameters, authIdentity }
};
return vectorizer;
},
aml: () => {
const generatedAMLVectorizer = generatedVectorizer;
const vectorizer = {
...generatedAMLVectorizer,
amlParameters: generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(
generatedAMLVectorizer.amlParameters
)
};
return vectorizer;
}
};
const defaultDeserializer = () => {
import_logger.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
return generatedVectorizer;
};
return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
}
function generatedKnowledgeSourceVectorizerToPublicVectorizer(generatedVectorizer) {
if (!generatedVectorizer) {
return generatedVectorizer;
}
const knownVectorizerDeserializers = {
azureOpenAI: () => {
const { parameters } = generatedVectorizer;
const authIdentity = convertSearchIndexerDataIdentityToPublic(parameters?.authIdentity);
const vectorizer = {
...generatedVectorizer,
parameters: { ...parameters, authIdentity }
};
return vectorizer;
}
};
const defaultDeserializer = () => {
import_logger.logger.warning(`Unsupported vectorizer kind: ${generatedVectorizer.kind}`);
return generatedVectorizer;
};
return (knownVectorizerDeserializers[generatedVectorizer.kind] ?? defaultDeserializer)();
}
function generatedAzureMachineLearningVectorizerParametersToPublicAzureMachineLearningVectorizerParameters(aMLParameters) {
if (!aMLParameters) {
return void 0;
}
const { resourceId, authenticationKey, scoringUri } = aMLParameters;
switch (true) {
case (resourceId !== void 0 && resourceId !== null): {
return {
...aMLParameters,
authKind: "token"
};
}
case (authenticationKey !== void 0 && authenticationKey !== null): {
return {
...aMLParameters,
apiKey: authenticationKey,
authKind: "key"
};
}
case (scoringUri !== void 0 && scoringUri !== null): {
return {
...aMLParameters,
authKind: "none"
};
}
}
import_logger.logger.warning("Unknown AML parameter kind");
return aMLParameters;
}
function generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration(generatedAlgorithmConfiguration) {
if (!generatedAlgorithmConfiguration) {
return void 0;
}
if (["hnsw", "exhaustiveKnn"].includes(generatedAlgorithmConfiguration.kind)) {
const algorithmConfiguration = generatedAlgorithmConfiguration;
const metric = algorithmConfiguration.parameters?.metric;
return {
...algorithmConfiguration,
parameters: { ...algorithmConfiguration.parameters, metric }
};
}
throw Error("Unsupported algorithm configuration");
}
function generatedVectorSearchToPublicVectorSearch(vectorSearch) {
if (!vectorSearch) {
return void 0;
}
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),
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 void 0;
}
if (searchIndexerDataIdentity.odatatype === "#Microsoft.Azure.Search.DataNoneIdentity") {
return searchIndexerDataIdentity;
} else {
return searchIndexerDataIdentity;
}
}
function convertDataChangeDetectionPolicyToPublic(dataChangeDetectionPolicy) {
if (!dataChangeDetectionPolicy) {
return void 0;
}
if (dataChangeDetectionPolicy.odatatype === "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy") {
return dataChangeDetectionPolicy;
} else {
return dataChangeDetectionPolicy;
}
}
function convertDataDeletionDetectionPolicyToPublic(dataDeletionDetectionPolicy) {
if (!dataDeletionDetectionPolicy) {
return void 0;
}
return dataDeletionDetectionPolicy;
}
function convertKnowledgeStoreToPublic(knowledgeStore) {
if (!knowledgeStore) {
return void 0;
}
return {
...knowledgeStore,
identity: convertSearchIndexerDataIdentityToPublic(knowledgeStore.identity)
};
}
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)
};
}
function convertKnowledgeBaseToGenerated(knowledgeBase) {
if (!knowledgeBase) {
return void 0;
}
return {
...knowledgeBase,
etag: knowledgeBase.etag,
encryptionKey: convertEncryptionKeyToGenerated(knowledgeBase.encryptionKey)
};
}
function convertKnowledgeSourceToPublic(knowledgeSource) {
if (!knowledgeSource) {
return void 0;
}
switch (knowledgeSource.kind) {
case "searchIndex": {
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
};
}
case "azureBlob": {
const { encryptionKey, azureBlobParameters } = knowledgeSource;
return {
...knowledgeSource,
kind: "azureBlob",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
azureBlobParameters: convertAzureBlobKnowledgeSourceParametersToPublic(azureBlobParameters)
};
}
case "indexedOneLake": {
const { encryptionKey, indexedOneLakeParameters } = knowledgeSource;
return {
...knowledgeSource,
kind: "indexedOneLake",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey),
indexedOneLakeParameters: {
fabricWorkspaceId: indexedOneLakeParameters.fabricWorkspaceId,
lakehouseId: indexedOneLakeParameters.lakehouseId,
ingestionParameters: convertKnowledgeIngestionParametersToPublic(
indexedOneLakeParameters.ingestionParameters
),
targetPath: indexedOneLakeParameters.targetPath,
createdResources: indexedOneLakeParameters.createdResources?.additionalProperties
}
};
}
case "web": {
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
kind: "web",
encryptionKey: convertEncryptionKeyToPublic(encryptionKey)
};
}
default: {
import_logger.logger.warning(`Unknown knowledge source kind ${knowledgeSource.kind}`);
return void 0;
}
}
}
function convertKnowledgeSourceToGenerated(knowledgeSource) {
if (!knowledgeSource) {
return void 0;
}
const { encryptionKey } = knowledgeSource;
return {
...knowledgeSource,
encryptionKey: convertEncryptionKeyToGenerated(encryptionKey)
};
}
function convertKnowledgeIngestionParametersToPublic(params) {
if (!params) {
return void 0;
}
const { embeddingModel, chatCompletionModel, identity, ...rest } = params;
return {
...rest,
embeddingModel: !embeddingModel ? embeddingModel : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
identity: convertSearchIndexerDataIdentityToPublic(identity),
chatCompletionModel: !chatCompletionModel ? chatCompletionModel : convertKnowledgeBaseModelToPublic(chatCompletionModel)
};
}
function convertAzureBlobKnowledgeSourceParametersToPublic(params) {
if (!params) {
return void 0;
}
const { embeddingModel, chatCompletionModel, identity, ...rest } = params.ingestionParameters ?? {};
return {
...rest,
embeddingModel: !embeddingModel ? embeddingModel : generatedKnowledgeSourceVectorizerToPublicVectorizer(embeddingModel),
identity: convertSearchIndexerDataIdentityToPublic(identity),
connectionString: params.connectionString,
containerName: params.containerName,
chatCompletionModel: !chatCompletionModel ? chatCompletionModel : convertKnowledgeBaseModelToPublic(chatCompletionModel)
};
}
function convertKnowledgeBaseModelToPublic(model) {
switch (model.kind) {
case "azureOpenAI": {
const { azureOpenAIParameters, ...rest } = model;
return {
...rest,
azureOpenAIParameters: convertAzureOpenAIParametersToPublic(azureOpenAIParameters)
};
}
default: {
import_logger.logger.warning("Unknown knowledge base model kind");
return model;
}
}
}
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;
return {
actionType: __actionType,
additionalProperties: documentProperties
};
});
}
function convertGeneratedFacetResultToPublic(facetResult) {
const { additionalProperties, ...rest } = facetResult;
return {
...additionalProperties,
...rest,
additionalProperties
};
}
function convertGeneratedFacetsToPublic(facets) {
if (!facets) {
return facets;
}
const result = {};
for (const [key, value] of Object.entries(facets)) {
result[key] = value.map(convertGeneratedFacetResultToPublic);
}
return result;
}
function convertGeneratedQueryAnswerResultToPublic(answerResult) {
const { additionalProperties, ...rest } = answerResult;
return {
...additionalProperties,
...rest,
additionalProperties
};
}
function convertGeneratedAnswersToPublic(answers) {
if (!answers) {
return answers;
}
return answers.map(convertGeneratedQueryAnswerResultToPublic);
}
function convertGeneratedQueryCaptionResultToPublic(captionResult) {
const { additionalProperties, ...rest } = captionResult;
return {
...additionalProperties,
...rest,
additionalProperties
};
}
function convertGeneratedCaptionsToPublic(captions) {
if (!captions) {
return captions;
}
return captions.map(convertGeneratedQueryCaptionResultToPublic);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
convertCognitiveServicesAccountToGenerated,
convertCognitiveServicesAccountToPublic,
convertDataChangeDetectionPolicyToPublic,
convertDataDeletionDetectionPolicyToPublic,
convertFieldsToGenerated,
convertFieldsToPublic,
convertGeneratedAnswersToPublic,
convertGeneratedCaptionsToPublic,
convertGeneratedFacetResultToPublic,
convertGeneratedFacetsToPublic,
convertGeneratedQueryAnswerResultToPublic,
convertGeneratedQueryCaptionResultToPublic,
convertKnowledgeBaseToGenerated,
convertKnowledgeBaseToPublic,
convertKnowledgeSourceToGenerated,
convertKnowledgeSourceToPublic,
convertPublicActionsToGeneratedActions,
convertSearchIndexerDataIdentityToPublic,
convertSimilarityToGenerated,
convertSimilarityToPublic,
convertSkillsToPublic,
convertTokenFiltersToGenerated,
defaultServiceVersion,
generatedDataSourceToPublicDataSource,
generatedIndexToPublicIndex,
generatedKnowledgeSourceVectorizerToPublicVectorizer,
generatedSearchIndexerToPublicSearchIndexer,
generatedSearchResultToPublicSearchResult,
generatedSkillsetToPublicSkillset,
generatedSuggestDocumentsResultToPublicSuggestDocumentsResult,
generatedSynonymMapToPublicSynonymMap,
generatedVectorSearchAlgorithmConfigurationToPublicVectorSearchAlgorithmConfiguration,
generatedVectorSearchToPublicVectorSearch,
generatedVectorSearchVectorizerToPublicVectorizer,
mapPagedAsyncIterable,
publicDataSourceToGeneratedDataSource,
publicIndexToGeneratedIndex,
publicSearchIndexerToGeneratedSearchIndexer,
publicSkillsetToGeneratedSkillset,
publicSynonymMapToGeneratedSynonymMap
});
//# sourceMappingURL=serviceUtils.js.map