@azure/search-documents

import type { KnowledgeSourceIngestionParameters } from "../knowledgeBases/models.js"; /** * This file contains only generated model types and their (de)serializers. * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input. */ /** Represents a synonym map definition. */ export interface SynonymMap { /** The name of the synonym map. */ name: string; /** The format of the synonym map. Only the 'solr' format is currently supported. */ format: "solr"; /** A series of synonym rules in the specified synonym map format. The rules must be separated by newlines. */ synonyms: string[]; /** A description of an encryption key that you create in Azure Key Vault. This key is used to provide an additional level of encryption-at-rest for your data when you want full assurance that no one, not even Microsoft, can decrypt your data. Once you have encrypted your data, it will always remain encrypted. The search service will ignore attempts to set this property to null. You can change this property as needed if you want to rotate your encryption key; Your data will be unaffected. Encryption with customer-managed keys is not available for free search services, and is only available for paid services created on or after January 1, 2019. */ encryptionKey?: SearchResourceEncryptionKey; /** The ETag of the synonym map. */ eTag?: string; } export declare function synonymMapSerializer(item: SynonymMap): any; export declare function synonymMapDeserializer(item: any): SynonymMap; /** A customer-managed encryption key in Azure Key Vault. Keys that you create and manage can be used to encrypt or decrypt data-at-rest, such as indexes and synonym maps. */ export interface SearchResourceEncryptionKey { /** The name of your Azure Key Vault key to be used to encrypt your data at rest. */ keyName: string; /** The version of your Azure Key Vault key to be used to encrypt your data at rest. */ keyVersion?: string; /** The URI of your Azure Key Vault, also referred to as DNS name, that contains the key to be used to encrypt your data at rest. An example URI might be `https://my-keyvault-name.vault.azure.net`. */ vaultUri: string; /** An explicit managed identity to use for this encryption key. If not specified and the access credentials property is null, the system-assigned managed identity is used. On update to the resource, if the explicit identity is unspecified, it remains unchanged. If "none" is specified, the value of this property is cleared. */ identity?: SearchIndexerDataIdentityUnion; /** An AAD Application ID that was granted the required access permissions to the Azure Key Vault that is to be used when encrypting your data at rest. The Application ID should not be confused with the Object ID for your AAD Application. */ applicationId?: string; /** The authentication key of the specified AAD application. */ applicationSecret?: string; } export declare function searchResourceEncryptionKeySerializer(item: SearchResourceEncryptionKey): any; export declare function searchResourceEncryptionKeyDeserializer(item: any): SearchResourceEncryptionKey; /** Credentials of a registered application created for your search service, used for authenticated access to the encryption keys stored in Azure Key Vault. */ export interface AzureActiveDirectoryApplicationCredentials { /** An AAD Application ID that was granted the required access permissions to the Azure Key Vault that is to be used when encrypting your data at rest. The Application ID should not be confused with the Object ID for your AAD Application. */ applicationId: string; /** The authentication key of the specified AAD application. */ applicationSecret?: string; } export declare function azureActiveDirectoryApplicationCredentialsSerializer(item: AzureActiveDirectoryApplicationCredentials): any; export declare function azureActiveDirectoryApplicationCredentialsDeserializer(item: any): AzureActiveDirectoryApplicationCredentials; /** Abstract base type for data identities. */ export interface SearchIndexerDataIdentity { /** A URI fragment specifying the type of identity. */ /** The discriminator possible values: #Microsoft.Azure.Search.DataNoneIdentity, #Microsoft.Azure.Search.DataUserAssignedIdentity */ odatatype: string; } export declare function searchIndexerDataIdentitySerializer(item: SearchIndexerDataIdentity): any; export declare function searchIndexerDataIdentityDeserializer(item: any): SearchIndexerDataIdentity; /** Alias for SearchIndexerDataIdentityUnion */ export type SearchIndexerDataIdentityUnion = SearchIndexerDataNoneIdentity | SearchIndexerDataUserAssignedIdentity | SearchIndexerDataIdentity; export declare function searchIndexerDataIdentityUnionSerializer(item: SearchIndexerDataIdentityUnion): any; export declare function searchIndexerDataIdentityUnionDeserializer(item: any): SearchIndexerDataIdentityUnion; /** Clears the identity property of a datasource. */ export interface SearchIndexerDataNoneIdentity extends SearchIndexerDataIdentity { /** The discriminator for derived types. */ odatatype: "#Microsoft.Azure.Search.DataNoneIdentity"; } export declare function searchIndexerDataNoneIdentitySerializer(item: SearchIndexerDataNoneIdentity): any; export declare function searchIndexerDataNoneIdentityDeserializer(item: any): SearchIndexerDataNoneIdentity; /** Specifies the identity for a datasource to use. */ export interface SearchIndexerDataUserAssignedIdentity extends SearchIndexerDataIdentity { /** The fully qualified Azure resource Id of a user assigned managed identity typically in the form "/subscriptions/12345678-1234-1234-1234-1234567890ab/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId" that should have been assigned to the search service. */ resourceId: string; /** A URI fragment specifying the type of identity. */ odatatype: "#Microsoft.Azure.Search.DataUserAssignedIdentity"; } export declare function searchIndexerDataUserAssignedIdentitySerializer(item: SearchIndexerDataUserAssignedIdentity): any; export declare function searchIndexerDataUserAssignedIdentityDeserializer(item: any): SearchIndexerDataUserAssignedIdentity; /** Response from a List SynonymMaps request. If successful, it includes the full definitions of all synonym maps. */ export interface ListSynonymMapsResult { /** The synonym maps in the Search service. */ readonly synonymMaps: SynonymMap[]; } export declare function listSynonymMapsResultDeserializer(item: any): ListSynonymMapsResult; export declare function synonymMapArraySerializer(result: Array<SynonymMap>): any[]; export declare function synonymMapArrayDeserializer(result: Array<SynonymMap>): any[]; /** Represents a search index definition, which describes the fields and search behavior of an index. */ export interface SearchIndex { /** The name of the index. */ name: string; /** The description of the index. */ description?: string; /** The fields of the index. */ fields: SearchField[]; /** The scoring profiles for the index. */ scoringProfiles?: ScoringProfile[]; /** The name of the scoring profile to use if none is specified in the query. If this property is not set and no scoring profile is specified in the query, then default scoring (tf-idf) will be used. */ defaultScoringProfile?: string; /** Options to control Cross-Origin Resource Sharing (CORS) for the index. */ corsOptions?: CorsOptions; /** The suggesters for the index. */ suggesters?: SearchSuggester[]; /** The analyzers for the index. */ analyzers?: LexicalAnalyzerUnion[]; /** The tokenizers for the index. */ tokenizers?: LexicalTokenizerUnion[]; /** The token filters for the index. */ tokenFilters?: TokenFilterUnion[]; /** The character filters for the index. */ charFilters?: CharFilterUnion[]; /** The normalizers for the index. */ normalizers?: LexicalNormalizerUnion[]; /** A description of an encryption key that you create in Azure Key Vault. This key is used to provide an additional level of encryption-at-rest for your data when you want full assurance that no one, not even Microsoft, can decrypt your data. Once you have encrypted your data, it will always remain encrypted. The search service will ignore attempts to set this property to null. You can change this property as needed if you want to rotate your encryption key; Your data will be unaffected. Encryption with customer-managed keys is not available for free search services, and is only available for paid services created on or after January 1, 2019. */ encryptionKey?: SearchResourceEncryptionKey; /** The type of similarity algorithm to be used when scoring and ranking the documents matching a search query. The similarity algorithm can only be defined at index creation time and cannot be modified on existing indexes. If null, the ClassicSimilarity algorithm is used. */ similarity?: SimilarityAlgorithmUnion; /** Defines parameters for a search index that influence semantic capabilities. */ semanticSearch?: SemanticSearch; /** Contains configuration options related to vector search. */ vectorSearch?: VectorSearch; /** The ETag of the index. */ eTag?: string; } export declare function searchIndexSerializer(item: SearchIndex): any; export declare function searchIndexDeserializer(item: any): SearchIndex; export declare function searchFieldArraySerializer(result: Array<SearchField>): any[]; export declare function searchFieldArrayDeserializer(result: Array<SearchField>): any[]; /** Represents a field in an index definition, which describes the name, data type, and search behavior of a field. */ export interface SearchField { /** The name of the field, which must be unique within the fields collection of the index or parent field. */ name: string; /** The data type of the field. */ type: SearchFieldDataType; /** A value indicating whether the field uniquely identifies documents in the index. Exactly one top-level field in each index must be chosen as the key field and it must be of type Edm.String. Key fields can be used to look up documents directly and update or delete specific documents. Default is false for simple fields and null for complex fields. */ key?: boolean; /** A value indicating whether the field can be returned in a search result. You can disable this option if you want to use a field (for example, margin) as a filter, sorting, or scoring mechanism but do not want the field to be visible to the end user. This property must be true for key fields, and it must be null for complex fields. This property can be changed on existing fields. Enabling this property does not cause any increase in index storage requirements. Default is true for simple fields, false for vector fields, and null for complex fields. */ retrievable?: boolean; /** An immutable value indicating whether the field will be persisted separately on disk to be returned in a search result. You can disable this option if you don't plan to return the field contents in a search response to save on storage overhead. This can only be set during index creation and only for vector fields. This property cannot be changed for existing fields or set as false for new fields. If this property is set as false, the property 'retrievable' must also be set to false. This property must be true or unset for key fields, for new fields, and for non-vector fields, and it must be null for complex fields. Disabling this property will reduce index storage requirements. The default is true for vector fields. */ stored?: boolean; /** A value indicating whether the field is full-text searchable. This means it will undergo analysis such as word-breaking during indexing. If you set a searchable field to a value like "sunny day", internally it will be split into the individual tokens "sunny" and "day". This enables full-text searches for these terms. Fields of type Edm.String or Collection(Edm.String) are searchable by default. This property must be false for simple fields of other non-string data types, and it must be null for complex fields. Note: searchable fields consume extra space in your index to accommodate additional tokenized versions of the field value for full-text searches. If you want to save space in your index and you don't need a field to be included in searches, set searchable to false. */ searchable?: boolean; /** A value indicating whether to enable the field to be referenced in $filter queries. filterable differs from searchable in how strings are handled. Fields of type Edm.String or Collection(Edm.String) that are filterable do not undergo word-breaking, so comparisons are for exact matches only. For example, if you set such a field f to "sunny day", $filter=f eq 'sunny' will find no matches, but $filter=f eq 'sunny day' will. This property must be null for complex fields. Default is true for simple fields and null for complex fields. */ filterable?: boolean; /** A value indicating whether to enable the field to be referenced in $orderby expressions. By default, the search engine sorts results by score, but in many experiences users will want to sort by fields in the documents. A simple field can be sortable only if it is single-valued (it has a single value in the scope of the parent document). Simple collection fields cannot be sortable, since they are multi-valued. Simple sub-fields of complex collections are also multi-valued, and therefore cannot be sortable. This is true whether it's an immediate parent field, or an ancestor field, that's the complex collection. Complex fields cannot be sortable and the sortable property must be null for such fields. The default for sortable is true for single-valued simple fields, false for multi-valued simple fields, and null for complex fields. */ sortable?: boolean; /** A value indicating whether to enable the field to be referenced in facet queries. Typically used in a presentation of search results that includes hit count by category (for example, search for digital cameras and see hits by brand, by megapixels, by price, and so on). This property must be null for complex fields. Fields of type Edm.GeographyPoint or Collection(Edm.GeographyPoint) cannot be facetable. Default is true for all other simple fields. */ facetable?: boolean; /** The name of the analyzer to use for the field. This option can be used only with searchable fields and it can't be set together with either searchAnalyzer or indexAnalyzer. Once the analyzer is chosen, it cannot be changed for the field. Must be null for complex fields. */ analyzerName?: LexicalAnalyzerName; /** The name of the analyzer used at search time for the field. This option can be used only with searchable fields. It must be set together with indexAnalyzer and it cannot be set together with the analyzer option. This property cannot be set to the name of a language analyzer; use the analyzer property instead if you need a language analyzer. This analyzer can be updated on an existing field. Must be null for complex fields. */ searchAnalyzerName?: LexicalAnalyzerName; /** The name of the analyzer used at indexing time for the field. This option can be used only with searchable fields. It must be set together with searchAnalyzer and it cannot be set together with the analyzer option. This property cannot be set to the name of a language analyzer; use the analyzer property instead if you need a language analyzer. Once the analyzer is chosen, it cannot be changed for the field. Must be null for complex fields. */ indexAnalyzerName?: LexicalAnalyzerName; /** The name of the normalizer to use for the field. This option can be used only with fields with filterable, sortable, or facetable enabled. Once the normalizer is chosen, it cannot be changed for the field. Must be null for complex fields. */ normalizerName?: LexicalNormalizerName; /** The dimensionality of the vector field. */ vectorSearchDimensions?: number; /** The name of the vector search profile that specifies the algorithm and vectorizer to use when searching the vector field. */ vectorSearchProfileName?: string; /** The encoding format to interpret the field contents. */ vectorEncodingFormat?: VectorEncodingFormat; /** A list of the names of synonym maps to associate with this field. This option can be used only with searchable fields. Currently only one synonym map per field is supported. Assigning a synonym map to a field ensures that query terms targeting that field are expanded at query-time using the rules in the synonym map. This attribute can be changed on existing fields. Must be null or an empty collection for complex fields. */ synonymMapNames?: string[]; /** A list of sub-fields if this is a field of type Edm.ComplexType or Collection(Edm.ComplexType). Must be null or empty for simple fields. */ fields?: SearchField[]; } export declare function searchFieldSerializer(item: SearchField): any; export declare function searchFieldDeserializer(item: any): SearchField; /** Defines the data type of a field in a search index. */ export declare enum KnownSearchFieldDataType { /** Indicates that a field contains a string. */ String = "Edm.String", /** Indicates that a field contains a 32-bit signed integer. */ Int32 = "Edm.Int32", /** Indicates that a field contains a 64-bit signed integer. */ Int64 = "Edm.Int64", /** Indicates that a field contains an IEEE double-precision floating point number. */ Double = "Edm.Double", /** Indicates that a field contains a Boolean value (true or false). */ Boolean = "Edm.Boolean", /** Indicates that a field contains a date/time value, including timezone information. */ DateTimeOffset = "Edm.DateTimeOffset", /** Indicates that a field contains a geo-location in terms of longitude and latitude. */ GeographyPoint = "Edm.GeographyPoint", /** Indicates that a field contains one or more complex objects that in turn have sub-fields of other types. */ Complex = "Edm.ComplexType", /** Indicates that a field contains a single-precision floating point number. This is only valid when used with Collection(Edm.Single). */ Single = "Edm.Single", /** Indicates that a field contains a half-precision floating point number. This is only valid when used with Collection(Edm.Half). */ Half = "Edm.Half", /** Indicates that a field contains a 16-bit signed integer. This is only valid when used with Collection(Edm.Int16). */ Int16 = "Edm.Int16", /** Indicates that a field contains a 8-bit signed integer. This is only valid when used with Collection(Edm.SByte). */ SByte = "Edm.SByte", /** Indicates that a field contains a 8-bit unsigned integer. This is only valid when used with Collection(Edm.Byte). */ Byte = "Edm.Byte" } /** * Defines the data type of a field in a search index. \ * {@link KnownSearchFieldDataType} can be used interchangeably with SearchFieldDataType, * this enum contains the known values that the service supports. * ### Known values supported by the service * **Edm.String**: Indicates that a field contains a string. \ * **Edm.Int32**: Indicates that a field contains a 32-bit signed integer. \ * **Edm.Int64**: Indicates that a field contains a 64-bit signed integer. \ * **Edm.Double**: Indicates that a field contains an IEEE double-precision floating point number. \ * **Edm.Boolean**: Indicates that a field contains a Boolean value (true or false). \ * **Edm.DateTimeOffset**: Indicates that a field contains a date\/time value, including timezone information. \ * **Edm.GeographyPoint**: Indicates that a field contains a geo-location in terms of longitude and latitude. \ * **Edm.ComplexType**: Indicates that a field contains one or more complex objects that in turn have sub-fields of other types. \ * **Edm.Single**: Indicates that a field contains a single-precision floating point number. This is only valid when used with Collection(Edm.Single). \ * **Edm.Half**: Indicates that a field contains a half-precision floating point number. This is only valid when used with Collection(Edm.Half). \ * **Edm.Int16**: Indicates that a field contains a 16-bit signed integer. This is only valid when used with Collection(Edm.Int16). \ * **Edm.SByte**: Indicates that a field contains a 8-bit signed integer. This is only valid when used with Collection(Edm.SByte). \ * **Edm.Byte**: Indicates that a field contains a 8-bit unsigned integer. This is only valid when used with Collection(Edm.Byte). */ export type SearchFieldDataType = string; /** Defines the names of all text analyzers supported by the search engine. */ export declare enum KnownLexicalAnalyzerName { /** Microsoft analyzer for Arabic. */ ArMicrosoft = "ar.microsoft", /** Lucene analyzer for Arabic. */ ArLucene = "ar.lucene", /** Lucene analyzer for Armenian. */ HyLucene = "hy.lucene", /** Microsoft analyzer for Bangla. */ BnMicrosoft = "bn.microsoft", /** Lucene analyzer for Basque. */ EuLucene = "eu.lucene", /** Microsoft analyzer for Bulgarian. */ BgMicrosoft = "bg.microsoft", /** Lucene analyzer for Bulgarian. */ BgLucene = "bg.lucene", /** Microsoft analyzer for Catalan. */ CaMicrosoft = "ca.microsoft", /** Lucene analyzer for Catalan. */ CaLucene = "ca.lucene", /** Microsoft analyzer for Chinese (Simplified). */ ZhHansMicrosoft = "zh-Hans.microsoft", /** Lucene analyzer for Chinese (Simplified). */ ZhHansLucene = "zh-Hans.lucene", /** Microsoft analyzer for Chinese (Traditional). */ ZhHantMicrosoft = "zh-Hant.microsoft", /** Lucene analyzer for Chinese (Traditional). */ ZhHantLucene = "zh-Hant.lucene", /** Microsoft analyzer for Croatian. */ HrMicrosoft = "hr.microsoft", /** Microsoft analyzer for Czech. */ CsMicrosoft = "cs.microsoft", /** Lucene analyzer for Czech. */ CsLucene = "cs.lucene", /** Microsoft analyzer for Danish. */ DaMicrosoft = "da.microsoft", /** Lucene analyzer for Danish. */ DaLucene = "da.lucene", /** Microsoft analyzer for Dutch. */ NlMicrosoft = "nl.microsoft", /** Lucene analyzer for Dutch. */ NlLucene = "nl.lucene", /** Microsoft analyzer for English. */ EnMicrosoft = "en.microsoft", /** Lucene analyzer for English. */ EnLucene = "en.lucene", /** Microsoft analyzer for Estonian. */ EtMicrosoft = "et.microsoft", /** Microsoft analyzer for Finnish. */ FiMicrosoft = "fi.microsoft", /** Lucene analyzer for Finnish. */ FiLucene = "fi.lucene", /** Microsoft analyzer for French. */ FrMicrosoft = "fr.microsoft", /** Lucene analyzer for French. */ FrLucene = "fr.lucene", /** Lucene analyzer for Galician. */ GlLucene = "gl.lucene", /** Microsoft analyzer for German. */ DeMicrosoft = "de.microsoft", /** Lucene analyzer for German. */ DeLucene = "de.lucene", /** Microsoft analyzer for Greek. */ ElMicrosoft = "el.microsoft", /** Lucene analyzer for Greek. */ ElLucene = "el.lucene", /** Microsoft analyzer for Gujarati. */ GuMicrosoft = "gu.microsoft", /** Microsoft analyzer for Hebrew. */ HeMicrosoft = "he.microsoft", /** Microsoft analyzer for Hindi. */ HiMicrosoft = "hi.microsoft", /** Lucene analyzer for Hindi. */ HiLucene = "hi.lucene", /** Microsoft analyzer for Hungarian. */ HuMicrosoft = "hu.microsoft", /** Lucene analyzer for Hungarian. */ HuLucene = "hu.lucene", /** Microsoft analyzer for Icelandic. */ IsMicrosoft = "is.microsoft", /** Microsoft analyzer for Indonesian (Bahasa). */ IdMicrosoft = "id.microsoft", /** Lucene analyzer for Indonesian. */ IdLucene = "id.lucene", /** Lucene analyzer for Irish. */ GaLucene = "ga.lucene", /** Microsoft analyzer for Italian. */ ItMicrosoft = "it.microsoft", /** Lucene analyzer for Italian. */ ItLucene = "it.lucene", /** Microsoft analyzer for Japanese. */ JaMicrosoft = "ja.microsoft", /** Lucene analyzer for Japanese. */ JaLucene = "ja.lucene", /** Microsoft analyzer for Kannada. */ KnMicrosoft = "kn.microsoft", /** Microsoft analyzer for Korean. */ KoMicrosoft = "ko.microsoft", /** Lucene analyzer for Korean. */ KoLucene = "ko.lucene", /** Microsoft analyzer for Latvian. */ LvMicrosoft = "lv.microsoft", /** Lucene analyzer for Latvian. */ LvLucene = "lv.lucene", /** Microsoft analyzer for Lithuanian. */ LtMicrosoft = "lt.microsoft", /** Microsoft analyzer for Malayalam. */ MlMicrosoft = "ml.microsoft", /** Microsoft analyzer for Malay (Latin). */ MsMicrosoft = "ms.microsoft", /** Microsoft analyzer for Marathi. */ MrMicrosoft = "mr.microsoft", /** Microsoft analyzer for Norwegian (BokmÃ¥l). */ NbMicrosoft = "nb.microsoft", /** Lucene analyzer for Norwegian. */ NoLucene = "no.lucene", /** Lucene analyzer for Persian. */ FaLucene = "fa.lucene", /** Microsoft analyzer for Polish. */ PlMicrosoft = "pl.microsoft", /** Lucene analyzer for Polish. */ PlLucene = "pl.lucene", /** Microsoft analyzer for Portuguese (Brazil). */ PtBrMicrosoft = "pt-BR.microsoft", /** Lucene analyzer for Portuguese (Brazil). */ PtBrLucene = "pt-BR.lucene", /** Microsoft analyzer for Portuguese (Portugal). */ PtPtMicrosoft = "pt-PT.microsoft", /** Lucene analyzer for Portuguese (Portugal). */ PtPtLucene = "pt-PT.lucene", /** Microsoft analyzer for Punjabi. */ PaMicrosoft = "pa.microsoft", /** Microsoft analyzer for Romanian. */ RoMicrosoft = "ro.microsoft", /** Lucene analyzer for Romanian. */ RoLucene = "ro.lucene", /** Microsoft analyzer for Russian. */ RuMicrosoft = "ru.microsoft", /** Lucene analyzer for Russian. */ RuLucene = "ru.lucene", /** Microsoft analyzer for Serbian (Cyrillic). */ SrCyrillicMicrosoft = "sr-cyrillic.microsoft", /** Microsoft analyzer for Serbian (Latin). */ SrLatinMicrosoft = "sr-latin.microsoft", /** Microsoft analyzer for Slovak. */ SkMicrosoft = "sk.microsoft", /** Microsoft analyzer for Slovenian. */ SlMicrosoft = "sl.microsoft", /** Microsoft analyzer for Spanish. */ EsMicrosoft = "es.microsoft", /** Lucene analyzer for Spanish. */ EsLucene = "es.lucene", /** Microsoft analyzer for Swedish. */ SvMicrosoft = "sv.microsoft", /** Lucene analyzer for Swedish. */ SvLucene = "sv.lucene", /** Microsoft analyzer for Tamil. */ TaMicrosoft = "ta.microsoft", /** Microsoft analyzer for Telugu. */ TeMicrosoft = "te.microsoft", /** Microsoft analyzer for Thai. */ ThMicrosoft = "th.microsoft", /** Lucene analyzer for Thai. */ ThLucene = "th.lucene", /** Microsoft analyzer for Turkish. */ TrMicrosoft = "tr.microsoft", /** Lucene analyzer for Turkish. */ TrLucene = "tr.lucene", /** Microsoft analyzer for Ukrainian. */ UkMicrosoft = "uk.microsoft", /** Microsoft analyzer for Urdu. */ UrMicrosoft = "ur.microsoft", /** Microsoft analyzer for Vietnamese. */ ViMicrosoft = "vi.microsoft", /** Standard Lucene analyzer. */ StandardLucene = "standard.lucene", /** Standard ASCII Folding Lucene analyzer. See https://learn.microsoft.com/rest/api/searchservice/Custom-analyzers-in-Azure-Search#Analyzers */ 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 */ 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 */ 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 */ 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 */ 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 */ Whitespace = "whitespace" } /** * Defines the names of all text analyzers supported by the search engine. \ * {@link KnownLexicalAnalyzerName} can be used interchangeably with LexicalAnalyzerName, * this enum contains the known values that the service supports. * ### Known values supported by the service * **ar.microsoft**: Microsoft analyzer for Arabic. \ * **ar.lucene**: Lucene analyzer for Arabic. \ * **hy.lucene**: Lucene analyzer for Armenian. \ * **bn.microsoft**: Microsoft analyzer for Bangla. \ * **eu.lucene**: Lucene analyzer for Basque. \ * **bg.microsoft**: Microsoft analyzer for Bulgarian. \ * **bg.lucene**: Lucene analyzer for Bulgarian. \ * **ca.microsoft**: Microsoft analyzer for Catalan. \ * **ca.lucene**: Lucene analyzer for Catalan. \ * **zh-Hans.microsoft**: Microsoft analyzer for Chinese (Simplified). \ * **zh-Hans.lucene**: Lucene analyzer for Chinese (Simplified). \ * **zh-Hant.microsoft**: Microsoft analyzer for Chinese (Traditional). \ * **zh-Hant.lucene**: Lucene analyzer for Chinese (Traditional). \ * **hr.microsoft**: Microsoft analyzer for Croatian. \ * **cs.microsoft**: Microsoft analyzer for Czech. \ * **cs.lucene**: Lucene analyzer for Czech. \ * **da.microsoft**: Microsoft analyzer for Danish. \ * **da.lucene**: Lucene analyzer for Danish. \ * **nl.microsoft**: Microsoft analyzer for Dutch. \ * **nl.lucene**: Lucene analyzer for Dutch. \ * **en.microsoft**: Microsoft analyzer for English. \ * **en.lucene**: Lucene analyzer for English. \ * **et.microsoft**: Microsoft analyzer for Estonian. \ * **fi.microsoft**: Microsoft analyzer for Finnish. \ * **fi.lucene**: Lucene analyzer for Finnish. \ * **fr.microsoft**: Microsoft analyzer for French. \ * **fr.lucene**: Lucene analyzer for French. \ * **gl.lucene**: Lucene analyzer for Galician. \ * **de.microsoft**: Microsoft analyzer for German. \ * **de.lucene**: Lucene analyzer for German. \ * **el.microsoft**: Microsoft analyzer for Greek. \ * **el.lucene**: Lucene analyzer for Greek. \ * **gu.microsoft**: Microsoft analyzer for Gujarati. \ * **he.microsoft**: Microsoft analyzer for Hebrew. \ * **hi.microsoft**: Microsoft analyzer for Hindi. \ * **hi.lucene**: Lucene analyzer for Hindi. \ * **hu.microsoft**: Microsoft analyzer for Hungarian. \ * **hu.lucene**: Lucene analyzer for Hungarian. \ * **is.microsoft**: Microsoft analyzer for Icelandic. \ * **id.microsoft**: Microsoft analyzer for Indonesian (Bahasa). \ * **id.lucene**: Lucene analyzer for Indonesian. \ * **ga.lucene**: Lucene analyzer for Irish. \ * **it.microsoft**: Microsoft analyzer for Italian. \ * **it.lucene**: Lucene analyzer for Italian. \ * **ja.microsoft**: Microsoft analyzer for Japanese. \ * **ja.lucene**: Lucene analyzer for Japanese. \ * **kn.microsoft**: Microsoft analyzer for Kannada. \ * **ko.microsoft**: Microsoft analyzer for Korean. \ * **ko.lucene**: Lucene analyzer for Korean. \ * **lv.microsoft**: Microsoft analyzer for Latvian. \ * **lv.lucene**: Lucene analyzer for Latvian. \ * **lt.microsoft**: Microsoft analyzer for Lithuanian. \ * **ml.microsoft**: Microsoft analyzer for Malayalam. \ * **ms.microsoft**: Microsoft analyzer for Malay (Latin). \ * **mr.microsoft**: Microsoft analyzer for Marathi. \ * **nb.microsoft**: Microsoft analyzer for Norwegian (BokmÃ¥l). \ * **no.lucene**: Lucene analyzer for Norwegian. \ * **fa.lucene**: Lucene analyzer for Persian. \ * **pl.microsoft**: Microsoft analyzer for Polish. \ * **pl.lucene**: Lucene analyzer for Polish. \ * **pt-BR.microsoft**: Microsoft analyzer for Portuguese (Brazil). \ * **pt-BR.lucene**: Lucene analyzer for Portuguese (Brazil). \ * **pt-PT.microsoft**: Microsoft analyzer for Portuguese (Portugal). \ * **pt-PT.lucene**: Lucene analyzer for Portuguese (Portugal). \ * **pa.microsoft**: Microsoft analyzer for Punjabi. \ * **ro.microsoft**: Microsoft analyzer for Romanian. \ * **ro.lucene**: Lucene analyzer for Romanian. \ * **ru.microsoft**: Microsoft analyzer for Russian. \ * **ru.lucene**: Lucene analyzer for Russian. \ * **sr-cyrillic.microsoft**: Microsoft analyzer for Serbian (Cyrillic). \ * **sr-latin.microsoft**: Microsoft analyzer for Serbian (Latin). \ * **sk.microsoft**: Microsoft analyzer for Slovak. \ * **sl.microsoft**: Microsoft analyzer for Slovenian. \ * **es.microsoft**: Microsoft analyzer for Spanish. \ * **es.lucene**: Lucene analyzer for Spanish. \ * **sv.microsoft**: Microsoft analyzer for Swedish. \ * **sv.lucene**: Lucene analyzer for Swedish. \ * **ta.microsoft**: Microsoft analyzer for Tamil. \ * **te.microsoft**: Microsoft analyzer for Telugu. \ * **th.microsoft**: Microsoft analyzer for Thai. \ * **th.lucene**: Lucene analyzer for Thai. \ * **tr.microsoft**: Microsoft analyzer for Turkish. \ * **tr.lucene**: Lucene analyzer for Turkish. \ * **uk.microsoft**: Microsoft analyzer for Ukrainian. \ * **ur.microsoft**: Microsoft analyzer for Urdu. \ * **vi.microsoft**: Microsoft analyzer for Vietnamese. \ * **standard.lucene**: Standard Lucene analyzer. \ * **standardasciifolding.lucene**: Standard ASCII Folding Lucene analyzer. See https:\//learn.microsoft.com\/rest\/api\/searchservice\/Custom-analyzers-in-Azure-Search#Analyzers \ * **keyword**: 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 \ * **pattern**: 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 \ * **simple**: 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 \ * **stop**: 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 \ * **whitespace**: 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 */ export type LexicalAnalyzerName = string; /** Defines the names of all text normalizers supported by the search engine. */ export declare enum 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 */ 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 */ 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 */ 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 */ 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 */ Uppercase = "uppercase" } /** * Defines the names of all text normalizers supported by the search engine. \ * {@link KnownLexicalNormalizerName} can be used interchangeably with LexicalNormalizerName, * this enum contains the known values that the service supports. * ### Known values supported by the service * **asciifolding**: 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 \ * **elision**: 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 \ * **lowercase**: Normalizes token text to lowercase. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/LowerCaseFilter.html \ * **standard**: 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 \ * **uppercase**: Normalizes token text to uppercase. See https:\//lucene.apache.org\/core\/6_6_1\/analyzers-common\/org\/apache\/lucene\/analysis\/core\/UpperCaseFilter.html */ export type LexicalNormalizerName = string; /** The encoding format for interpreting vector field contents. */ export declare enum KnownVectorEncodingFormat { /** Encoding format representing bits packed into a wider data type. */ PackedBit = "packedBit" } /** * The encoding format for interpreting vector field contents. \ * {@link KnownVectorEncodingFormat} can be used interchangeably with VectorEncodingFormat, * this enum contains the known values that the service supports. * ### Known values supported by the service * **packedBit**: Encoding format representing bits packed into a wider data type. */ export type VectorEncodingFormat = string; export declare function scoringProfileArraySerializer(result: Array<ScoringProfile>): any[]; export declare function scoringProfileArrayDeserializer(result: Array<ScoringProfile>): any[]; /** Defines parameters for a search index that influence scoring in search queries. */ export interface ScoringProfile { /** The name of the scoring profile. */ name: string; /** Parameters that boost scoring based on text matches in certain index fields. */ textWeights?: TextWeights; /** The collection of functions that influence the scoring of documents. */ functions?: ScoringFunctionUnion[]; /** A value indicating how the results of individual scoring functions should be combined. Defaults to "Sum". Ignored if there are no scoring functions. */ functionAggregation?: ScoringFunctionAggregation; } export declare function scoringProfileSerializer(item: ScoringProfile): any; export declare function scoringProfileDeserializer(item: any): ScoringProfile; /** Defines weights on index fields for which matches should boost scoring in search queries. */ export interface TextWeights { /** The dictionary of per-field weights to boost document scoring. The keys are field names and the values are the weights for each field. */ weights: Record<string, number>; } export declare function textWeightsSerializer(item: TextWeights): any; export declare function textWeightsDeserializer(item: any): TextWeights; export declare function scoringFunctionUnionArraySerializer(result: Array<ScoringFunctionUnion>): any[]; export declare function scoringFunctionUnionArrayDeserializer(result: Array<ScoringFunctionUnion>): any[]; /** Base type for functions that can modify document scores during ranking. */ export interface ScoringFunction { /** The name of the field used as input to the scoring function. */ fieldName: string; /** A multiplier for the raw score. Must be a positive number not equal to 1.0. */ boost: number; /** A value indicating how boosting will be interpolated across document scores; defaults to "Linear". */ interpolation?: ScoringFunctionInterpolation; /** Type of ScoringFunction. */ /** The discriminator possible values: distance, freshness, magnitude, tag */ type: string; } export declare function scoringFunctionSerializer(item: ScoringFunction): any; export declare function scoringFunctionDeserializer(item: any): ScoringFunction; /** Alias for ScoringFunctionUnion */ export type ScoringFunctionUnion = DistanceScoringFunction | FreshnessScoringFunction | MagnitudeScoringFunction | TagScoringFunction | ScoringFunction; export declare function scoringFunctionUnionSerializer(item: ScoringFunctionUnion): any; export declare function scoringFunctionUnionDeserializer(item: any): ScoringFunctionUnion; /** Defines the function used to interpolate score boosting across a range of documents. */ export type ScoringFunctionInterpolation = "linear" | "constant" | "quadratic" | "logarithmic"; /** Defines a function that boosts scores based on distance from a geographic location. */ export interface DistanceScoringFunction extends ScoringFunction { /** Parameter values for the distance scoring function. */ parameters: DistanceScoringParameters; /** Indicates the type of function to use. Valid values include magnitude, freshness, distance, and tag. The function type must be lower case. */ type: "distance"; } export declare function distanceScoringFunctionSerializer(item: DistanceScoringFunction): any; export declare function distanceScoringFunctionDeserializer(item: any): DistanceScoringFunction; /** Provides parameter values to a distance scoring function. */ export interface DistanceScoringParameters { /** The name of the parameter passed in search queries to specify the reference location. */ referencePointParameter: string; /** The distance in kilometers from the reference location where the boosting range ends. */ boostingDistance: number; } export declare function distanceScoringParametersSerializer(item: DistanceScoringParameters): any; export declare function distanceScoringParametersDeserializer(item: any): DistanceScoringParameters; /** Defines a function that boosts scores based on the value of a date-time field. */ export interface FreshnessScoringFunction extends ScoringFunction { /** Parameter values for the freshness scoring function. */ parameters: FreshnessScoringParameters; /** Indicates the type of function to use. Valid values include magnitude, freshness, distance, and tag. The function type must be lower case. */ type: "freshness"; } export declare function freshnessScoringFunctionSerializer(item: FreshnessScoringFunction): any; export declare function freshnessScoringFunctionDeserializer(item: any): FreshnessScoringFunction; /** Provides parameter values to a freshness scoring function. */ export interface FreshnessScoringParameters { /** The expiration period after which boosting will stop for a particular document. */ boostingDuration: string; } export declare function freshnessScoringParametersSerializer(item: FreshnessScoringParameters): any; export declare function freshnessScoringParametersDeserializer(item: any): FreshnessScoringParameters; /** Defines a function that boosts scores based on the magnitude of a numeric field. */ export interface MagnitudeScoringFunction extends ScoringFunction { /** Parameter values for the magnitude scoring function. */ parameters: MagnitudeScoringParameters; /** Indicates the type of function to use. Valid values include magnitude, freshness, distance, and tag. The function type must be lower case. */ type: "magnitude"; } export declare function magnitudeScoringFunctionSerializer(item: MagnitudeScoringFunction): any; export declare function magnitudeScoringFunctionDeserializer(item: any): MagnitudeScoringFunction; /** Provides parameter values to a magnitude scoring function. */ export interface MagnitudeScoringParameters { /** The field value at which boosting starts. */ boostingRangeStart: number; /** The field value at which boosting ends. */ boostingRangeEnd: number; /** A value indicating whether to apply a constant boost for field values beyond the range end value; default is false. */ shouldBoostBeyondRangeByConstant?: boolean; } export declare function magnitudeScoringParametersSerializer(item: MagnitudeScoringParameters): any; export declare function magnitudeScoringParametersDeserializer(item: any): MagnitudeScoringParameters; /** Defines a function that boosts scores of documents with string values matching a given list of tags. */ export interface TagScoringFunction extends ScoringFunction { /** Parameter values for the tag scoring function. */ parameters: TagScoringParameters; /** Indicates the type of function to use. Valid values include magnitude, freshness, distance, and tag. The function type must be lower case. */ type: "tag"; } export declare function tagScoringFunctionSerializer(item: TagScoringFunction): any; export declare function tagScoringFunctionDeserializer(item: any): TagScoringFunction; /** Provides parameter values to a tag scoring function. */ export interface TagScoringParameters { /** The name of the parameter passed in search queries to specify the list of tags to compare against the target field. */ tagsParameter: string; } export declare function tagScoringParametersSerializer(item: TagScoringParameters): any; export declare function tagScoringParametersDeserializer(item: any): TagScoringParameters; /** Defines the aggregation function used to combine the results of all the scoring functions in a scoring profile. */ export type ScoringFunctionAggregation = "sum" | "average" | "minimum" | "maximum" | "firstMatching" | "product"; /** Defines options to control Cross-Origin Resource Sharing (CORS) for an index. */ export interface CorsOptions { /** The list of origins from which JavaScript code will be granted access to your index. Can contain a list of hosts of the form {protocol}://{fully-qualified-domain-name}[:{port#}], or a single '*' to allow all origins (not recommended). */ allowedOrigins: string[]; /** The duration for which browsers should cache CORS preflight responses. Defaults to 5 minutes. */ maxAgeInSeconds?: number; } export declare function corsOptionsSerializer(item: CorsOptions): any; export declare function corsOptionsDeserializer(item: any): CorsOptions; export declare function searchSuggesterArraySerializer(result: Array<SearchSuggester>): any[]; export declare function searchSuggesterArrayDeserializer(result: Array<SearchSuggester>): any[]; /** Defines how the Suggest API should apply to a group of fields in the index. */ export interface SearchSuggester { /** The name of the suggester. */ name: string; /** A value indicating the capabilities of the suggester. */ searchMode: "analyzingInfixMatching"; /** The list of field names to which the suggester applies. Each field must be searchable. */ sourceFields: string[]; } export declare function searchSuggesterSerializer(item: SearchSuggester): any; export declare function searchSuggesterDeserializer(item: any): SearchSuggester; export declare function lexicalAnalyzerUnionArraySerializer(result: Array<LexicalAnalyzerUnion>): any[]; export declare function lexicalAnalyzerUnionArrayDeserializer(result: Array<LexicalAnalyzerUnion>): any[]; /** Base type for analyzers. */ export interface LexicalAnalyzer { /** The discriminator for derived types. */ /** The discriminator possible values: #Microsoft.Azure.Search.CustomAnalyzer, #Microsoft.Azure.Search.PatternAnalyzer, #Microsoft.Azure.Search.StandardAnalyzer, #Microsoft.Azure.Search.StopAnalyzer */ odatatype: string; /** The name of the analyzer. It must only contain letters, digits, spaces, dashes or underscores, can only start and end with alphanumeric characters, and is limited to 128 characters. */ name: string; } export declare function lexicalAnalyzerSerializer(item: LexicalAnalyzer): any; export declare function lexicalAnalyzerDeserializer(item: any): LexicalAnalyzer; /** Alias for LexicalAnalyzerUnion */ export type LexicalAnalyzerUnion = CustomAnalyzer | PatternAnalyzer | LuceneStandardAnalyzer | StopAnalyzer | LexicalAnalyzer; export declare function lexicalAnalyzerUnionSerializer(item: LexicalAnalyzerUnion): any; export declare function lexicalAnalyzerUnionDeserializer(item: any): LexicalAnalyzerUnion; /** Allows you to take control over the process of converting text into indexable/searchable tokens. It's a user-defined configuration consisting of a single predefined tokenizer and one or more filters. The tokenizer is responsible for breaking text into tokens, and the filters for modifying tokens emitted by the tokenizer. */ export interface CustomAnalyzer extends LexicalAnalyzer { /** The name of the tokenizer to use to divide continuous text into a sequence of tokens, such as breaking a sentence into words. */ tokenizer: LexicalTokenizerName; /** A list of token filters used to filter out or modify the tokens generated by a tokenizer. For example, you can specify a lowercase f