@azure/search-documents
Version:
Azure client library to use AI Search for node.js and browser.
962 lines • 266 kB
JavaScript
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { buildNewlineCollection } from "../../../../../static-helpers/serialization/build-newline-collection.js";
import { buildPipeCollection } from "../../../../../static-helpers/serialization/build-pipe-collection.js";
import { areAllPropsUndefined } from "../../../../../static-helpers/serialization/check-prop-undefined.js";
import { parseNewlineCollection } from "../../../../../static-helpers/serialization/parse-newline-collection.js";
import { parsePipeCollection } from "../../../../../static-helpers/serialization/parse-pipe-collection.js";
import { serializeRecord } from "../../../../../static-helpers/serialization/serialize-record.js";
import { knowledgeSourceIngestionParametersSerializer, knowledgeSourceIngestionParametersDeserializer, } from "../knowledgeBases/models.js";
export function synonymMapSerializer(item) {
return {
name: item["name"],
format: item["format"],
synonyms: buildNewlineCollection(item["synonyms"].map((p) => {
return p;
})),
encryptionKey: !item["encryptionKey"]
? item["encryptionKey"]
: searchResourceEncryptionKeySerializer(item["encryptionKey"]),
"@odata.etag": item["eTag"],
};
}
export function synonymMapDeserializer(item) {
return {
name: item["name"],
format: item["format"],
synonyms: parseNewlineCollection(item["synonyms"]),
encryptionKey: !item["encryptionKey"]
? item["encryptionKey"]
: searchResourceEncryptionKeyDeserializer(item["encryptionKey"]),
eTag: item["@odata.etag"],
};
}
export function searchResourceEncryptionKeySerializer(item) {
return {
keyVaultKeyName: item["keyName"],
keyVaultKeyVersion: item["keyVersion"],
keyVaultUri: item["vaultUri"],
accessCredentials: areAllPropsUndefined(item, ["applicationId", "applicationSecret"])
? undefined
: _searchResourceEncryptionKeyAccessCredentialsSerializer(item),
identity: !item["identity"]
? item["identity"]
: searchIndexerDataIdentityUnionSerializer(item["identity"]),
};
}
export function searchResourceEncryptionKeyDeserializer(item) {
return {
keyName: item["keyVaultKeyName"],
keyVersion: item["keyVaultKeyVersion"],
vaultUri: item["keyVaultUri"],
...(!item["accessCredentials"]
? item["accessCredentials"]
: _searchResourceEncryptionKeyAccessCredentialsDeserializer(item["accessCredentials"])),
identity: !item["identity"]
? item["identity"]
: searchIndexerDataIdentityUnionDeserializer(item["identity"]),
};
}
export function azureActiveDirectoryApplicationCredentialsSerializer(item) {
return { applicationId: item["applicationId"], applicationSecret: item["applicationSecret"] };
}
export function azureActiveDirectoryApplicationCredentialsDeserializer(item) {
return {
applicationId: item["applicationId"],
applicationSecret: item["applicationSecret"],
};
}
export function searchIndexerDataIdentitySerializer(item) {
return { "@odata.type": item["odatatype"] };
}
export function searchIndexerDataIdentityDeserializer(item) {
return {
odatatype: item["@odata.type"],
};
}
export function searchIndexerDataIdentityUnionSerializer(item) {
switch (item.odatatype) {
case "#Microsoft.Azure.Search.DataNoneIdentity":
return searchIndexerDataNoneIdentitySerializer(item);
case "#Microsoft.Azure.Search.DataUserAssignedIdentity":
return searchIndexerDataUserAssignedIdentitySerializer(item);
default:
return searchIndexerDataIdentitySerializer(item);
}
}
export function searchIndexerDataIdentityUnionDeserializer(item) {
switch (item["@odata.type"]) {
case "#Microsoft.Azure.Search.DataNoneIdentity":
return searchIndexerDataNoneIdentityDeserializer(item);
case "#Microsoft.Azure.Search.DataUserAssignedIdentity":
return searchIndexerDataUserAssignedIdentityDeserializer(item);
default:
return searchIndexerDataIdentityDeserializer(item);
}
}
export function searchIndexerDataNoneIdentitySerializer(item) {
return { "@odata.type": item["odatatype"] };
}
export function searchIndexerDataNoneIdentityDeserializer(item) {
return {
odatatype: item["@odata.type"],
};
}
export function searchIndexerDataUserAssignedIdentitySerializer(item) {
return { "@odata.type": item["odatatype"], userAssignedIdentity: item["resourceId"] };
}
export function searchIndexerDataUserAssignedIdentityDeserializer(item) {
return {
odatatype: item["@odata.type"],
resourceId: item["userAssignedIdentity"],
};
}
export function listSynonymMapsResultDeserializer(item) {
return {
synonymMaps: synonymMapArrayDeserializer(item["value"]),
};
}
export function synonymMapArraySerializer(result) {
return result.map((item) => {
return synonymMapSerializer(item);
});
}
export function synonymMapArrayDeserializer(result) {
return result.map((item) => {
return synonymMapDeserializer(item);
});
}
export function searchIndexSerializer(item) {
return {
name: item["name"],
description: item["description"],
fields: searchFieldArraySerializer(item["fields"]),
scoringProfiles: !item["scoringProfiles"]
? item["scoringProfiles"]
: scoringProfileArraySerializer(item["scoringProfiles"]),
defaultScoringProfile: item["defaultScoringProfile"],
corsOptions: !item["corsOptions"]
? item["corsOptions"]
: corsOptionsSerializer(item["corsOptions"]),
suggesters: !item["suggesters"]
? item["suggesters"]
: searchSuggesterArraySerializer(item["suggesters"]),
analyzers: !item["analyzers"]
? item["analyzers"]
: lexicalAnalyzerUnionArraySerializer(item["analyzers"]),
tokenizers: !item["tokenizers"]
? item["tokenizers"]
: lexicalTokenizerUnionArraySerializer(item["tokenizers"]),
tokenFilters: !item["tokenFilters"]
? item["tokenFilters"]
: tokenFilterUnionArraySerializer(item["tokenFilters"]),
charFilters: !item["charFilters"]
? item["charFilters"]
: charFilterUnionArraySerializer(item["charFilters"]),
normalizers: !item["normalizers"]
? item["normalizers"]
: lexicalNormalizerUnionArraySerializer(item["normalizers"]),
encryptionKey: !item["encryptionKey"]
? item["encryptionKey"]
: searchResourceEncryptionKeySerializer(item["encryptionKey"]),
similarity: !item["similarity"]
? item["similarity"]
: similarityAlgorithmUnionSerializer(item["similarity"]),
semantic: !item["semanticSearch"]
? item["semanticSearch"]
: semanticSearchSerializer(item["semanticSearch"]),
vectorSearch: !item["vectorSearch"]
? item["vectorSearch"]
: vectorSearchSerializer(item["vectorSearch"]),
"@odata.etag": item["eTag"],
};
}
export function searchIndexDeserializer(item) {
return {
name: item["name"],
description: item["description"],
fields: searchFieldArrayDeserializer(item["fields"]),
scoringProfiles: !item["scoringProfiles"]
? item["scoringProfiles"]
: scoringProfileArrayDeserializer(item["scoringProfiles"]),
defaultScoringProfile: item["defaultScoringProfile"],
corsOptions: !item["corsOptions"]
? item["corsOptions"]
: corsOptionsDeserializer(item["corsOptions"]),
suggesters: !item["suggesters"]
? item["suggesters"]
: searchSuggesterArrayDeserializer(item["suggesters"]),
analyzers: !item["analyzers"]
? item["analyzers"]
: lexicalAnalyzerUnionArrayDeserializer(item["analyzers"]),
tokenizers: !item["tokenizers"]
? item["tokenizers"]
: lexicalTokenizerUnionArrayDeserializer(item["tokenizers"]),
tokenFilters: !item["tokenFilters"]
? item["tokenFilters"]
: tokenFilterUnionArrayDeserializer(item["tokenFilters"]),
charFilters: !item["charFilters"]
? item["charFilters"]
: charFilterUnionArrayDeserializer(item["charFilters"]),
normalizers: !item["normalizers"]
? item["normalizers"]
: lexicalNormalizerUnionArrayDeserializer(item["normalizers"]),
encryptionKey: !item["encryptionKey"]
? item["encryptionKey"]
: searchResourceEncryptionKeyDeserializer(item["encryptionKey"]),
similarity: !item["similarity"]
? item["similarity"]
: similarityAlgorithmUnionDeserializer(item["similarity"]),
semanticSearch: !item["semantic"]
? item["semantic"]
: semanticSearchDeserializer(item["semantic"]),
vectorSearch: !item["vectorSearch"]
? item["vectorSearch"]
: vectorSearchDeserializer(item["vectorSearch"]),
eTag: item["@odata.etag"],
};
}
export function searchFieldArraySerializer(result) {
return result.map((item) => {
return searchFieldSerializer(item);
});
}
export function searchFieldArrayDeserializer(result) {
return result.map((item) => {
return searchFieldDeserializer(item);
});
}
export function searchFieldSerializer(item) {
return {
name: item["name"],
type: item["type"],
key: item["key"],
retrievable: item["retrievable"],
stored: item["stored"],
searchable: item["searchable"],
filterable: item["filterable"],
sortable: item["sortable"],
facetable: item["facetable"],
analyzer: item["analyzerName"],
searchAnalyzer: item["searchAnalyzerName"],
indexAnalyzer: item["indexAnalyzerName"],
normalizer: item["normalizerName"],
dimensions: item["vectorSearchDimensions"],
vectorSearchProfile: item["vectorSearchProfileName"],
vectorEncoding: item["vectorEncodingFormat"],
synonymMaps: !item["synonymMapNames"]
? item["synonymMapNames"]
: item["synonymMapNames"].map((p) => {
return p;
}),
fields: !item["fields"] ? item["fields"] : searchFieldArraySerializer(item["fields"]),
};
}
export function searchFieldDeserializer(item) {
return {
name: item["name"],
type: item["type"],
key: item["key"],
retrievable: item["retrievable"],
stored: item["stored"],
searchable: item["searchable"],
filterable: item["filterable"],
sortable: item["sortable"],
facetable: item["facetable"],
analyzerName: item["analyzer"],
searchAnalyzerName: item["searchAnalyzer"],
indexAnalyzerName: item["indexAnalyzer"],
normalizerName: item["normalizer"],
vectorSearchDimensions: item["dimensions"],
vectorSearchProfileName: item["vectorSearchProfile"],
vectorEncodingFormat: item["vectorEncoding"],
synonymMapNames: !item["synonymMaps"]
? item["synonymMaps"]
: item["synonymMaps"].map((p) => {
return p;
}),
fields: !item["fields"] ? item["fields"] : searchFieldArrayDeserializer(item["fields"]),
};
}
/** Defines the data type of a field in a search index. */
export var KnownSearchFieldDataType;
(function (KnownSearchFieldDataType) {
/** Indicates that a field contains a string. */
KnownSearchFieldDataType["String"] = "Edm.String";
/** Indicates that a field contains a 32-bit signed integer. */
KnownSearchFieldDataType["Int32"] = "Edm.Int32";
/** Indicates that a field contains a 64-bit signed integer. */
KnownSearchFieldDataType["Int64"] = "Edm.Int64";
/** Indicates that a field contains an IEEE double-precision floating point number. */
KnownSearchFieldDataType["Double"] = "Edm.Double";
/** Indicates that a field contains a Boolean value (true or false). */
KnownSearchFieldDataType["Boolean"] = "Edm.Boolean";
/** Indicates that a field contains a date/time value, including timezone information. */
KnownSearchFieldDataType["DateTimeOffset"] = "Edm.DateTimeOffset";
/** Indicates that a field contains a geo-location in terms of longitude and latitude. */
KnownSearchFieldDataType["GeographyPoint"] = "Edm.GeographyPoint";
/** Indicates that a field contains one or more complex objects that in turn have sub-fields of other types. */
KnownSearchFieldDataType["Complex"] = "Edm.ComplexType";
/** Indicates that a field contains a single-precision floating point number. This is only valid when used with Collection(Edm.Single). */
KnownSearchFieldDataType["Single"] = "Edm.Single";
/** Indicates that a field contains a half-precision floating point number. This is only valid when used with Collection(Edm.Half). */
KnownSearchFieldDataType["Half"] = "Edm.Half";
/** Indicates that a field contains a 16-bit signed integer. This is only valid when used with Collection(Edm.Int16). */
KnownSearchFieldDataType["Int16"] = "Edm.Int16";
/** Indicates that a field contains a 8-bit signed integer. This is only valid when used with Collection(Edm.SByte). */
KnownSearchFieldDataType["SByte"] = "Edm.SByte";
/** Indicates that a field contains a 8-bit unsigned integer. This is only valid when used with Collection(Edm.Byte). */
KnownSearchFieldDataType["Byte"] = "Edm.Byte";
})(KnownSearchFieldDataType || (KnownSearchFieldDataType = {}));
/** Defines the names of all text analyzers supported by the search engine. */
export var KnownLexicalAnalyzerName;
(function (KnownLexicalAnalyzerName) {
/** Microsoft analyzer for Arabic. */
KnownLexicalAnalyzerName["ArMicrosoft"] = "ar.microsoft";
/** Lucene analyzer for Arabic. */
KnownLexicalAnalyzerName["ArLucene"] = "ar.lucene";
/** Lucene analyzer for Armenian. */
KnownLexicalAnalyzerName["HyLucene"] = "hy.lucene";
/** Microsoft analyzer for Bangla. */
KnownLexicalAnalyzerName["BnMicrosoft"] = "bn.microsoft";
/** Lucene analyzer for Basque. */
KnownLexicalAnalyzerName["EuLucene"] = "eu.lucene";
/** Microsoft analyzer for Bulgarian. */
KnownLexicalAnalyzerName["BgMicrosoft"] = "bg.microsoft";
/** Lucene analyzer for Bulgarian. */
KnownLexicalAnalyzerName["BgLucene"] = "bg.lucene";
/** Microsoft analyzer for Catalan. */
KnownLexicalAnalyzerName["CaMicrosoft"] = "ca.microsoft";
/** Lucene analyzer for Catalan. */
KnownLexicalAnalyzerName["CaLucene"] = "ca.lucene";
/** Microsoft analyzer for Chinese (Simplified). */
KnownLexicalAnalyzerName["ZhHansMicrosoft"] = "zh-Hans.microsoft";
/** Lucene analyzer for Chinese (Simplified). */
KnownLexicalAnalyzerName["ZhHansLucene"] = "zh-Hans.lucene";
/** Microsoft analyzer for Chinese (Traditional). */
KnownLexicalAnalyzerName["ZhHantMicrosoft"] = "zh-Hant.microsoft";
/** Lucene analyzer for Chinese (Traditional). */
KnownLexicalAnalyzerName["ZhHantLucene"] = "zh-Hant.lucene";
/** Microsoft analyzer for Croatian. */
KnownLexicalAnalyzerName["HrMicrosoft"] = "hr.microsoft";
/** Microsoft analyzer for Czech. */
KnownLexicalAnalyzerName["CsMicrosoft"] = "cs.microsoft";
/** Lucene analyzer for Czech. */
KnownLexicalAnalyzerName["CsLucene"] = "cs.lucene";
/** Microsoft analyzer for Danish. */
KnownLexicalAnalyzerName["DaMicrosoft"] = "da.microsoft";
/** Lucene analyzer for Danish. */
KnownLexicalAnalyzerName["DaLucene"] = "da.lucene";
/** Microsoft analyzer for Dutch. */
KnownLexicalAnalyzerName["NlMicrosoft"] = "nl.microsoft";
/** Lucene analyzer for Dutch. */
KnownLexicalAnalyzerName["NlLucene"] = "nl.lucene";
/** Microsoft analyzer for English. */
KnownLexicalAnalyzerName["EnMicrosoft"] = "en.microsoft";
/** Lucene analyzer for English. */
KnownLexicalAnalyzerName["EnLucene"] = "en.lucene";
/** Microsoft analyzer for Estonian. */
KnownLexicalAnalyzerName["EtMicrosoft"] = "et.microsoft";
/** Microsoft analyzer for Finnish. */
KnownLexicalAnalyzerName["FiMicrosoft"] = "fi.microsoft";
/** Lucene analyzer for Finnish. */
KnownLexicalAnalyzerName["FiLucene"] = "fi.lucene";
/** Microsoft analyzer for French. */
KnownLexicalAnalyzerName["FrMicrosoft"] = "fr.microsoft";
/** Lucene analyzer for French. */
KnownLexicalAnalyzerName["FrLucene"] = "fr.lucene";
/** Lucene analyzer for Galician. */
KnownLexicalAnalyzerName["GlLucene"] = "gl.lucene";
/** Microsoft analyzer for German. */
KnownLexicalAnalyzerName["DeMicrosoft"] = "de.microsoft";
/** Lucene analyzer for German. */
KnownLexicalAnalyzerName["DeLucene"] = "de.lucene";
/** Microsoft analyzer for Greek. */
KnownLexicalAnalyzerName["ElMicrosoft"] = "el.microsoft";
/** Lucene analyzer for Greek. */
KnownLexicalAnalyzerName["ElLucene"] = "el.lucene";
/** Microsoft analyzer for Gujarati. */
KnownLexicalAnalyzerName["GuMicrosoft"] = "gu.microsoft";
/** Microsoft analyzer for Hebrew. */
KnownLexicalAnalyzerName["HeMicrosoft"] = "he.microsoft";
/** Microsoft analyzer for Hindi. */
KnownLexicalAnalyzerName["HiMicrosoft"] = "hi.microsoft";
/** Lucene analyzer for Hindi. */
KnownLexicalAnalyzerName["HiLucene"] = "hi.lucene";
/** Microsoft analyzer for Hungarian. */
KnownLexicalAnalyzerName["HuMicrosoft"] = "hu.microsoft";
/** Lucene analyzer for Hungarian. */
KnownLexicalAnalyzerName["HuLucene"] = "hu.lucene";
/** Microsoft analyzer for Icelandic. */
KnownLexicalAnalyzerName["IsMicrosoft"] = "is.microsoft";
/** Microsoft analyzer for Indonesian (Bahasa). */
KnownLexicalAnalyzerName["IdMicrosoft"] = "id.microsoft";
/** Lucene analyzer for Indonesian. */
KnownLexicalAnalyzerName["IdLucene"] = "id.lucene";
/** Lucene analyzer for Irish. */
KnownLexicalAnalyzerName["GaLucene"] = "ga.lucene";
/** Microsoft analyzer for Italian. */
KnownLexicalAnalyzerName["ItMicrosoft"] = "it.microsoft";
/** Lucene analyzer for Italian. */
KnownLexicalAnalyzerName["ItLucene"] = "it.lucene";
/** Microsoft analyzer for Japanese. */
KnownLexicalAnalyzerName["JaMicrosoft"] = "ja.microsoft";
/** Lucene analyzer for Japanese. */
KnownLexicalAnalyzerName["JaLucene"] = "ja.lucene";
/** Microsoft analyzer for Kannada. */
KnownLexicalAnalyzerName["KnMicrosoft"] = "kn.microsoft";
/** Microsoft analyzer for Korean. */
KnownLexicalAnalyzerName["KoMicrosoft"] = "ko.microsoft";
/** Lucene analyzer for Korean. */
KnownLexicalAnalyzerName["KoLucene"] = "ko.lucene";
/** Microsoft analyzer for Latvian. */
KnownLexicalAnalyzerName["LvMicrosoft"] = "lv.microsoft";
/** Lucene analyzer for Latvian. */
KnownLexicalAnalyzerName["LvLucene"] = "lv.lucene";
/** Microsoft analyzer for Lithuanian. */
KnownLexicalAnalyzerName["LtMicrosoft"] = "lt.microsoft";
/** Microsoft analyzer for Malayalam. */
KnownLexicalAnalyzerName["MlMicrosoft"] = "ml.microsoft";
/** Microsoft analyzer for Malay (Latin). */
KnownLexicalAnalyzerName["MsMicrosoft"] = "ms.microsoft";
/** Microsoft analyzer for Marathi. */
KnownLexicalAnalyzerName["MrMicrosoft"] = "mr.microsoft";
/** Microsoft analyzer for Norwegian (Bokmål). */
KnownLexicalAnalyzerName["NbMicrosoft"] = "nb.microsoft";
/** Lucene analyzer for Norwegian. */
KnownLexicalAnalyzerName["NoLucene"] = "no.lucene";
/** Lucene analyzer for Persian. */
KnownLexicalAnalyzerName["FaLucene"] = "fa.lucene";
/** Microsoft analyzer for Polish. */
KnownLexicalAnalyzerName["PlMicrosoft"] = "pl.microsoft";
/** Lucene analyzer for Polish. */
KnownLexicalAnalyzerName["PlLucene"] = "pl.lucene";
/** Microsoft analyzer for Portuguese (Brazil). */
KnownLexicalAnalyzerName["PtBrMicrosoft"] = "pt-BR.microsoft";
/** Lucene analyzer for Portuguese (Brazil). */
KnownLexicalAnalyzerName["PtBrLucene"] = "pt-BR.lucene";
/** Microsoft analyzer for Portuguese (Portugal). */
KnownLexicalAnalyzerName["PtPtMicrosoft"] = "pt-PT.microsoft";
/** Lucene analyzer for Portuguese (Portugal). */
KnownLexicalAnalyzerName["PtPtLucene"] = "pt-PT.lucene";
/** Microsoft analyzer for Punjabi. */
KnownLexicalAnalyzerName["PaMicrosoft"] = "pa.microsoft";
/** Microsoft analyzer for Romanian. */
KnownLexicalAnalyzerName["RoMicrosoft"] = "ro.microsoft";
/** Lucene analyzer for Romanian. */
KnownLexicalAnalyzerName["RoLucene"] = "ro.lucene";
/** Microsoft analyzer for Russian. */
KnownLexicalAnalyzerName["RuMicrosoft"] = "ru.microsoft";
/** Lucene analyzer for Russian. */
KnownLexicalAnalyzerName["RuLucene"] = "ru.lucene";
/** Microsoft analyzer for Serbian (Cyrillic). */
KnownLexicalAnalyzerName["SrCyrillicMicrosoft"] = "sr-cyrillic.microsoft";
/** Microsoft analyzer for Serbian (Latin). */
KnownLexicalAnalyzerName["SrLatinMicrosoft"] = "sr-latin.microsoft";
/** Microsoft analyzer for Slovak. */
KnownLexicalAnalyzerName["SkMicrosoft"] = "sk.microsoft";
/** Microsoft analyzer for Slovenian. */
KnownLexicalAnalyzerName["SlMicrosoft"] = "sl.microsoft";
/** Microsoft analyzer for Spanish. */
KnownLexicalAnalyzerName["EsMicrosoft"] = "es.microsoft";
/** Lucene analyzer for Spanish. */
KnownLexicalAnalyzerName["EsLucene"] = "es.lucene";
/** Microsoft analyzer for Swedish. */
KnownLexicalAnalyzerName["SvMicrosoft"] = "sv.microsoft";
/** Lucene analyzer for Swedish. */
KnownLexicalAnalyzerName["SvLucene"] = "sv.lucene";
/** Microsoft analyzer for Tamil. */
KnownLexicalAnalyzerName["TaMicrosoft"] = "ta.microsoft";
/** Microsoft analyzer for Telugu. */
KnownLexicalAnalyzerName["TeMicrosoft"] = "te.microsoft";
/** Microsoft analyzer for Thai. */
KnownLexicalAnalyzerName["ThMicrosoft"] = "th.microsoft";
/** Lucene analyzer for Thai. */
KnownLexicalAnalyzerName["ThLucene"] = "th.lucene";
/** Microsoft analyzer for Turkish. */
KnownLexicalAnalyzerName["TrMicrosoft"] = "tr.microsoft";
/** Lucene analyzer for Turkish. */
KnownLexicalAnalyzerName["TrLucene"] = "tr.lucene";
/** Microsoft analyzer for Ukrainian. */
KnownLexicalAnalyzerName["UkMicrosoft"] = "uk.microsoft";
/** Microsoft analyzer for Urdu. */
KnownLexicalAnalyzerName["UrMicrosoft"] = "ur.microsoft";
/** Microsoft analyzer for Vietnamese. */
KnownLexicalAnalyzerName["ViMicrosoft"] = "vi.microsoft";
/** Standard Lucene analyzer. */
KnownLexicalAnalyzerName["StandardLucene"] = "standard.lucene";
/** Standard ASCII Folding Lucene analyzer. See https://learn.microsoft.com/rest/api/searchservice/Custom-analyzers-in-Azure-Search#Analyzers */
KnownLexicalAnalyzerName["StandardAsciiFoldingLucene"] = "standardasciifolding.lucene";
/** Treats the entire content of a field as a single token. This is useful for data like zip codes, ids, and some product names. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/KeywordAnalyzer.html */
KnownLexicalAnalyzerName["Keyword"] = "keyword";
/** Flexibly separates text into terms via a regular expression pattern. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/PatternAnalyzer.html */
KnownLexicalAnalyzerName["Pattern"] = "pattern";
/** Divides text at non-letters and converts them to lower case. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/SimpleAnalyzer.html */
KnownLexicalAnalyzerName["Simple"] = "simple";
/** Divides text at non-letters; Applies the lowercase and stopword token filters. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/StopAnalyzer.html */
KnownLexicalAnalyzerName["Stop"] = "stop";
/** An analyzer that uses the whitespace tokenizer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/WhitespaceAnalyzer.html */
KnownLexicalAnalyzerName["Whitespace"] = "whitespace";
})(KnownLexicalAnalyzerName || (KnownLexicalAnalyzerName = {}));
/** Defines the names of all text normalizers supported by the search engine. */
export var KnownLexicalNormalizerName;
(function (KnownLexicalNormalizerName) {
/** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ASCIIFoldingFilter.html */
KnownLexicalNormalizerName["AsciiFolding"] = "asciifolding";
/** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/util/ElisionFilter.html */
KnownLexicalNormalizerName["Elision"] = "elision";
/** Normalizes token text to lowercase. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/LowerCaseFilter.html */
KnownLexicalNormalizerName["Lowercase"] = "lowercase";
/** Standard normalizer, which consists of lowercase and asciifolding. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/reverse/ReverseStringFilter.html */
KnownLexicalNormalizerName["Standard"] = "standard";
/** Normalizes token text to uppercase. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/UpperCaseFilter.html */
KnownLexicalNormalizerName["Uppercase"] = "uppercase";
})(KnownLexicalNormalizerName || (KnownLexicalNormalizerName = {}));
/** The encoding format for interpreting vector field contents. */
export var KnownVectorEncodingFormat;
(function (KnownVectorEncodingFormat) {
/** Encoding format representing bits packed into a wider data type. */
KnownVectorEncodingFormat["PackedBit"] = "packedBit";
})(KnownVectorEncodingFormat || (KnownVectorEncodingFormat = {}));
export function scoringProfileArraySerializer(result) {
return result.map((item) => {
return scoringProfileSerializer(item);
});
}
export function scoringProfileArrayDeserializer(result) {
return result.map((item) => {
return scoringProfileDeserializer(item);
});
}
export function scoringProfileSerializer(item) {
return {
name: item["name"],
text: !item["textWeights"] ? item["textWeights"] : textWeightsSerializer(item["textWeights"]),
functions: !item["functions"]
? item["functions"]
: scoringFunctionUnionArraySerializer(item["functions"]),
functionAggregation: item["functionAggregation"],
};
}
export function scoringProfileDeserializer(item) {
return {
name: item["name"],
textWeights: !item["text"] ? item["text"] : textWeightsDeserializer(item["text"]),
functions: !item["functions"]
? item["functions"]
: scoringFunctionUnionArrayDeserializer(item["functions"]),
functionAggregation: item["functionAggregation"],
};
}
export function textWeightsSerializer(item) {
return { weights: item["weights"] };
}
export function textWeightsDeserializer(item) {
return {
weights: Object.fromEntries(Object.entries(item["weights"]).map(([k, p]) => [k, p])),
};
}
export function scoringFunctionUnionArraySerializer(result) {
return result.map((item) => {
return scoringFunctionUnionSerializer(item);
});
}
export function scoringFunctionUnionArrayDeserializer(result) {
return result.map((item) => {
return scoringFunctionUnionDeserializer(item);
});
}
export function scoringFunctionSerializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
};
}
export function scoringFunctionDeserializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
};
}
export function scoringFunctionUnionSerializer(item) {
switch (item.type) {
case "distance":
return distanceScoringFunctionSerializer(item);
case "freshness":
return freshnessScoringFunctionSerializer(item);
case "magnitude":
return magnitudeScoringFunctionSerializer(item);
case "tag":
return tagScoringFunctionSerializer(item);
default:
return scoringFunctionSerializer(item);
}
}
export function scoringFunctionUnionDeserializer(item) {
switch (item["type"]) {
case "distance":
return distanceScoringFunctionDeserializer(item);
case "freshness":
return freshnessScoringFunctionDeserializer(item);
case "magnitude":
return magnitudeScoringFunctionDeserializer(item);
case "tag":
return tagScoringFunctionDeserializer(item);
default:
return scoringFunctionDeserializer(item);
}
}
export function distanceScoringFunctionSerializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
distance: distanceScoringParametersSerializer(item["parameters"]),
};
}
export function distanceScoringFunctionDeserializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
parameters: distanceScoringParametersDeserializer(item["distance"]),
};
}
export function distanceScoringParametersSerializer(item) {
return {
referencePointParameter: item["referencePointParameter"],
boostingDistance: item["boostingDistance"],
};
}
export function distanceScoringParametersDeserializer(item) {
return {
referencePointParameter: item["referencePointParameter"],
boostingDistance: item["boostingDistance"],
};
}
export function freshnessScoringFunctionSerializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
freshness: freshnessScoringParametersSerializer(item["parameters"]),
};
}
export function freshnessScoringFunctionDeserializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
parameters: freshnessScoringParametersDeserializer(item["freshness"]),
};
}
export function freshnessScoringParametersSerializer(item) {
return { boostingDuration: item["boostingDuration"] };
}
export function freshnessScoringParametersDeserializer(item) {
return {
boostingDuration: item["boostingDuration"],
};
}
export function magnitudeScoringFunctionSerializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
magnitude: magnitudeScoringParametersSerializer(item["parameters"]),
};
}
export function magnitudeScoringFunctionDeserializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
parameters: magnitudeScoringParametersDeserializer(item["magnitude"]),
};
}
export function magnitudeScoringParametersSerializer(item) {
return {
boostingRangeStart: item["boostingRangeStart"],
boostingRangeEnd: item["boostingRangeEnd"],
constantBoostBeyondRange: item["shouldBoostBeyondRangeByConstant"],
};
}
export function magnitudeScoringParametersDeserializer(item) {
return {
boostingRangeStart: item["boostingRangeStart"],
boostingRangeEnd: item["boostingRangeEnd"],
shouldBoostBeyondRangeByConstant: item["constantBoostBeyondRange"],
};
}
export function tagScoringFunctionSerializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
tag: tagScoringParametersSerializer(item["parameters"]),
};
}
export function tagScoringFunctionDeserializer(item) {
return {
fieldName: item["fieldName"],
boost: item["boost"],
interpolation: item["interpolation"],
type: item["type"],
parameters: tagScoringParametersDeserializer(item["tag"]),
};
}
export function tagScoringParametersSerializer(item) {
return { tagsParameter: item["tagsParameter"] };
}
export function tagScoringParametersDeserializer(item) {
return {
tagsParameter: item["tagsParameter"],
};
}
export function corsOptionsSerializer(item) {
return {
allowedOrigins: item["allowedOrigins"].map((p) => {
return p;
}),
maxAgeInSeconds: item["maxAgeInSeconds"],
};
}
export function corsOptionsDeserializer(item) {
return {
allowedOrigins: item["allowedOrigins"].map((p) => {
return p;
}),
maxAgeInSeconds: item["maxAgeInSeconds"],
};
}
export function searchSuggesterArraySerializer(result) {
return result.map((item) => {
return searchSuggesterSerializer(item);
});
}
export function searchSuggesterArrayDeserializer(result) {
return result.map((item) => {
return searchSuggesterDeserializer(item);
});
}
export function searchSuggesterSerializer(item) {
return {
name: item["name"],
searchMode: item["searchMode"],
sourceFields: item["sourceFields"].map((p) => {
return p;
}),
};
}
export function searchSuggesterDeserializer(item) {
return {
name: item["name"],
searchMode: item["searchMode"],
sourceFields: item["sourceFields"].map((p) => {
return p;
}),
};
}
export function lexicalAnalyzerUnionArraySerializer(result) {
return result.map((item) => {
return lexicalAnalyzerUnionSerializer(item);
});
}
export function lexicalAnalyzerUnionArrayDeserializer(result) {
return result.map((item) => {
return lexicalAnalyzerUnionDeserializer(item);
});
}
export function lexicalAnalyzerSerializer(item) {
return { "@odata.type": item["odatatype"], name: item["name"] };
}
export function lexicalAnalyzerDeserializer(item) {
return {
odatatype: item["@odata.type"],
name: item["name"],
};
}
export function lexicalAnalyzerUnionSerializer(item) {
switch (item.odatatype) {
case "#Microsoft.Azure.Search.CustomAnalyzer":
return customAnalyzerSerializer(item);
case "#Microsoft.Azure.Search.PatternAnalyzer":
return patternAnalyzerSerializer(item);
case "#Microsoft.Azure.Search.StandardAnalyzer":
return luceneStandardAnalyzerSerializer(item);
case "#Microsoft.Azure.Search.StopAnalyzer":
return stopAnalyzerSerializer(item);
default:
return lexicalAnalyzerSerializer(item);
}
}
export function lexicalAnalyzerUnionDeserializer(item) {
switch (item["@odata.type"]) {
case "#Microsoft.Azure.Search.CustomAnalyzer":
return customAnalyzerDeserializer(item);
case "#Microsoft.Azure.Search.PatternAnalyzer":
return patternAnalyzerDeserializer(item);
case "#Microsoft.Azure.Search.StandardAnalyzer":
return luceneStandardAnalyzerDeserializer(item);
case "#Microsoft.Azure.Search.StopAnalyzer":
return stopAnalyzerDeserializer(item);
default:
return lexicalAnalyzerDeserializer(item);
}
}
export function customAnalyzerSerializer(item) {
return {
"@odata.type": item["odatatype"],
name: item["name"],
tokenizer: item["tokenizer"],
tokenFilters: !item["tokenFilters"]
? item["tokenFilters"]
: item["tokenFilters"].map((p) => {
return p;
}),
charFilters: !item["charFilters"]
? item["charFilters"]
: item["charFilters"].map((p) => {
return p;
}),
};
}
export function customAnalyzerDeserializer(item) {
return {
odatatype: item["@odata.type"],
name: item["name"],
tokenizer: item["tokenizer"],
tokenFilters: !item["tokenFilters"]
? item["tokenFilters"]
: item["tokenFilters"].map((p) => {
return p;
}),
charFilters: !item["charFilters"]
? item["charFilters"]
: item["charFilters"].map((p) => {
return p;
}),
};
}
/** Defines the names of all tokenizers supported by the search engine. */
export var KnownLexicalTokenizerName;
(function (KnownLexicalTokenizerName) {
/** Grammar-based tokenizer that is suitable for processing most European-language documents. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/standard/ClassicTokenizer.html */
KnownLexicalTokenizerName["Classic"] = "classic";
/** Tokenizes the input from an edge into n-grams of the given size(s). See https://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/EdgeNGramTokenizer.html */
KnownLexicalTokenizerName["EdgeNGram"] = "edgeNGram";
/** Emits the entire input as a single token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/KeywordTokenizer.html */
KnownLexicalTokenizerName["Keyword"] = "keyword_v2";
/** Divides text at non-letters. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/LetterTokenizer.html */
KnownLexicalTokenizerName["Letter"] = "letter";
/** Divides text at non-letters and converts them to lower case. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/LowerCaseTokenizer.html */
KnownLexicalTokenizerName["Lowercase"] = "lowercase";
/** Divides text using language-specific rules. */
KnownLexicalTokenizerName["MicrosoftLanguageTokenizer"] = "microsoft_language_tokenizer";
/** Divides text using language-specific rules and reduces words to their base forms. */
KnownLexicalTokenizerName["MicrosoftLanguageStemmingTokenizer"] = "microsoft_language_stemming_tokenizer";
/** Tokenizes the input into n-grams of the given size(s). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/NGramTokenizer.html */
KnownLexicalTokenizerName["NGram"] = "nGram";
/** Tokenizer for path-like hierarchies. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/path/PathHierarchyTokenizer.html */
KnownLexicalTokenizerName["PathHierarchy"] = "path_hierarchy_v2";
/** Tokenizer that uses regex pattern matching to construct distinct tokens. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/pattern/PatternTokenizer.html */
KnownLexicalTokenizerName["Pattern"] = "pattern";
/** Standard Lucene analyzer; Composed of the standard tokenizer, lowercase filter and stop filter. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/standard/StandardTokenizer.html */
KnownLexicalTokenizerName["Standard"] = "standard_v2";
/** Tokenizes urls and emails as one token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/standard/UAX29URLEmailTokenizer.html */
KnownLexicalTokenizerName["UaxUrlEmail"] = "uax_url_email";
/** Divides text at whitespace. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/WhitespaceTokenizer.html */
KnownLexicalTokenizerName["Whitespace"] = "whitespace";
})(KnownLexicalTokenizerName || (KnownLexicalTokenizerName = {}));
/** Defines the names of all token filters supported by the search engine. */
export var KnownTokenFilterName;
(function (KnownTokenFilterName) {
/** A token filter that applies the Arabic normalizer to normalize the orthography. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ar/ArabicNormalizationFilter.html */
KnownTokenFilterName["ArabicNormalization"] = "arabic_normalization";
/** Strips all characters after an apostrophe (including the apostrophe itself). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/tr/ApostropheFilter.html */
KnownTokenFilterName["Apostrophe"] = "apostrophe";
/** Converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if such equivalents exist. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ASCIIFoldingFilter.html */
KnownTokenFilterName["AsciiFolding"] = "asciifolding";
/** Forms bigrams of CJK terms that are generated from the standard tokenizer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/cjk/CJKBigramFilter.html */
KnownTokenFilterName["CjkBigram"] = "cjk_bigram";
/** Normalizes CJK width differences. Folds full-width ASCII variants into the equivalent basic Latin, and half-width Katakana variants into the equivalent Kana. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/cjk/CJKWidthFilter.html */
KnownTokenFilterName["CjkWidth"] = "cjk_width";
/** Removes English possessives, and dots from acronyms. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/standard/ClassicFilter.html */
KnownTokenFilterName["Classic"] = "classic";
/** Construct bigrams for frequently occurring terms while indexing. Single terms are still indexed too, with bigrams overlaid. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/commongrams/CommonGramsFilter.html */
KnownTokenFilterName["CommonGram"] = "common_grams";
/** Generates n-grams of the given size(s) starting from the front or the back of an input token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/EdgeNGramTokenFilter.html */
KnownTokenFilterName["EdgeNGram"] = "edgeNGram_v2";
/** Removes elisions. For example, "l'avion" (the plane) will be converted to "avion" (plane). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/util/ElisionFilter.html */
KnownTokenFilterName["Elision"] = "elision";
/** Normalizes German characters according to the heuristics of the German2 snowball algorithm. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/de/GermanNormalizationFilter.html */
KnownTokenFilterName["GermanNormalization"] = "german_normalization";
/** Normalizes text in Hindi to remove some differences in spelling variations. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/hi/HindiNormalizationFilter.html */
KnownTokenFilterName["HindiNormalization"] = "hindi_normalization";
/** Normalizes the Unicode representation of text in Indian languages. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/in/IndicNormalizationFilter.html */
KnownTokenFilterName["IndicNormalization"] = "indic_normalization";
/** Emits each incoming token twice, once as keyword and once as non-keyword. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/KeywordRepeatFilter.html */
KnownTokenFilterName["KeywordRepeat"] = "keyword_repeat";
/** A high-performance kstem filter for English. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/en/KStemFilter.html */
KnownTokenFilterName["KStem"] = "kstem";
/** Removes words that are too long or too short. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/LengthFilter.html */
KnownTokenFilterName["Length"] = "length";
/** Limits the number of tokens while indexing. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/LimitTokenCountFilter.html */
KnownTokenFilterName["Limit"] = "limit";
/** Normalizes token text to lower case. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/LowerCaseFilter.html */
KnownTokenFilterName["Lowercase"] = "lowercase";
/** Generates n-grams of the given size(s). See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ngram/NGramTokenFilter.html */
KnownTokenFilterName["NGram"] = "nGram_v2";
/** Applies normalization for Persian. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/fa/PersianNormalizationFilter.html */
KnownTokenFilterName["PersianNormalization"] = "persian_normalization";
/** Create tokens for phonetic matches. See https://lucene.apache.org/core/4_10_3/analyzers-phonetic/org/apache/lucene/analysis/phonetic/package-tree.html */
KnownTokenFilterName["Phonetic"] = "phonetic";
/** Uses the Porter stemming algorithm to transform the token stream. See http://tartarus.org/~martin/PorterStemmer */
KnownTokenFilterName["PorterStem"] = "porter_stem";
/** Reverses the token string. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/reverse/ReverseStringFilter.html */
KnownTokenFilterName["Reverse"] = "reverse";
/** Normalizes use of the interchangeable Scandinavian characters. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ScandinavianNormalizationFilter.html */
KnownTokenFilterName["ScandinavianNormalization"] = "scandinavian_normalization";
/** Folds Scandinavian characters åÅäæÄÆ->a and öÖøØ->o. It also discriminates against use of double vowels aa, ae, ao, oe and oo, leaving just the first one. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/ScandinavianFoldingFilter.html */
KnownTokenFilterName["ScandinavianFoldingNormalization"] = "scandinavian_folding";
/** Creates combinations of tokens as a single token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/shingle/ShingleFilter.html */
KnownTokenFilterName["Shingle"] = "shingle";
/** A filter that stems words using a Snowball-generated stemmer. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/snowball/SnowballFilter.html */
KnownTokenFilterName["Snowball"] = "snowball";
/** Normalizes the Unicode representation of Sorani text. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/ckb/SoraniNormalizationFilter.html */
KnownTokenFilterName["SoraniNormalization"] = "sorani_normalization";
/** Language specific stemming filter. See https://learn.microsoft.com/rest/api/searchservice/Custom-analyzers-in-Azure-Search#TokenFilters */
KnownTokenFilterName["Stemmer"] = "stemmer";
/** Removes stop words from a token stream. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/core/StopFilter.html */
KnownTokenFilterName["Stopwords"] = "stopwords";
/** Trims leading and trailing whitespace from tokens. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/TrimFilter.html */
KnownTokenFilterName["Trim"] = "trim";
/** Truncates the terms to a specific length. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/TruncateTokenFilter.html */
KnownTokenFilterName["Truncate"] = "truncate";
/** Filters out tokens with same text as the previous token. See http://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/miscellaneous/RemoveDuplicatesTokenFilter.html */
KnownTokenFilterName["Unique"] = "unique";
/** Normalizes token text to upper case. See https://lucene.apache.org/core/6_6_1/analyzers-common/org/apache/lucene/analysis/core/UpperCaseFilter.html */
KnownTokenFilterName["Uppercase"] = "uppercase";
/** Splits words into subwords and performs optional transformations on subword groups. */
KnownTokenFilterName["WordDelimiter"] = "word_delimiter";
})(KnownTokenFilterName || (KnownTokenFilterName = {}));
/** Defines the names of all character filters supported by the search engine. */
export var KnownCharFilterName;
(function (KnownCharFilterName) {
/** A character filter that attempts to strip out HTML constructs. See https://lucene.apache.org/core/4_10_3/analyzers-common/org/apache/lucene/analysis/charfilter/HTMLStripCharFilter.html */
KnownCharFilterName["HtmlStrip"] = "html_strip";
})(KnownCharFilterName || (KnownCharFilterName = {}));
export function patternAnalyzerSerializer(item) {
return {
"@odata.type": ite