// Type definitions for elastic.js v1.2.0 // Project: https://www.npmjs.com/package/elastic.js // Definitions by: Oleksii Trekhleb // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped export = elasticjs; export as namespace elasticjs; declare module elasticjs { export interface Facet {} export interface Geo {} export interface Suggest {} export interface Generator {} export interface Query {} export interface Filter {} export interface Aggregation {} export interface ScoreFunction {} export class AggregationMixin implements Aggregation { /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): AggregationMixin; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): AggregationMixin; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A container Filter that allows Boolean AND composition of Filters. */ export class AndFilter implements Filter { /* A container Filter that allows Boolean AND composition of Filters. */ constructor(f: Filter | Filter[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): AndFilter; /* Sets the cache key. */ cacheKey(key: string): AndFilter; /* Sets the filters for the filter. If fltr is a single Filter, it is added to the current filters. If fltr is an array of Filters, then they replace all existing filters. */ filters(fltr: Filter | Filter[]): AndFilter; /* Sets the filter name. */ name(name: string): AndFilter; /* Returns the filter object. */ toJSON(): AndFilter; } /* A single-value metrics aggregation that computes the average of numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. */ export class AvgAggregation implements Aggregation { /* Aggregation that computes the average of numeric values that are extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): AvgAggregation; /* The script language being used. */ lang(language: string): AvgAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): AvgAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): AvgAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): AvgAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A BoolFilter allows you to build Boolean filter constructs from individual filters. Similar in concept to Boolean query, except that the clauses are other filters. Can be placed within queries that accept a filter. */ export class BoolFilter implements Filter { /* A Filter that matches documents matching boolean combinations of other filters. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): BoolFilter; /* Sets the cache key. */ cacheKey(key: string): BoolFilter; /* Adds filter to boolean container. Given filter "must" appear in matching documents. If passed a single Filter it is added to the list of existing filters. If passed an array of Filters, they replace all existing filters. */ must(oFilter: Filter | Filter[]): BoolFilter; /* Adds filter to boolean container. Given filter "must not" appear in matching documents. If passed a single Filter it is added to the list of existing filters. If passed an array of Filters, they replace all existing filters. */ mustNot(oFilter: Filter | Filter[]): BoolFilter; /* Sets the filter name. */ name(name: string): BoolFilter; /* Adds filter to boolean container. Given filter "should" appear in matching documents. If passed a single Filter it is added to the list of existing filters. If passed an array of Filters, they replace all existing filters. */ should(oFilter: Filter | Filter[]): BoolFilter; /* Returns the filter object. */ toJSON(): BoolFilter; } /* A boolQuery allows you to build Boolean query constructs from individual term or phrase queries. For example you might want to search for documents containing the terms javascript and python. */ export class BoolQuery implements Query { /* A Query that matches documents matching boolean combinations of other queries, e.g. termQuerys, phraseQuerys or other boolQuerys. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets if the Query should be enhanced with a MatchAllQuery in order to act as a pure exclude when only negative (mustNot) clauses exist. Default: true. */ adjustPureNegative(trueFalse: string): BoolQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: number): BoolQuery; /* Enables or disables similarity coordinate scoring of documents matching the Query. Default: false. */ disableCoord(trueFalse: string): BoolQuery; /* Sets the number of optional clauses that must match. By default no optional clauses are necessary for a match (unless there are no required clauses). If this method is used, then the specified number of clauses is required. Use of this method is totally independent of specifying that any specific clauses are required (or prohibited). This number will only be compared against the number of matching optional clauses. */ minimumNumberShouldMatch(minMatch: number): BoolQuery; /* Adds query to boolean container. Given query "must" appear in matching documents. */ must(oQuery: Object): BoolQuery; /* Adds query to boolean container. Given query "must not" appear in matching documents. */ mustNot(oQuery: Object): BoolQuery; /* Adds query to boolean container. Given query "should" appear in matching documents. */ should(oQuery: Object): BoolQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The boost_factor score allows you to multiply the score by the provided boost_factor. This can sometimes be desired since boost value set on specific queries gets normalized, while for this score function it does not. */ export class BoostFactorScoreFunction implements ScoreFunction { /* Multiply the score by the provided boost_factor. */ constructor(boostVal: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost factor. */ boost(b: number): BoostFactorScoreFunction; /* Adds a filter whose matching documents will have the score function applied. */ filter(oFilter: Filter): BoostFactorScoreFunction; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The boosting query can be used to effectively demote results that match a given query. Unlike the “NOT” clause in bool query, this still selects documents that contain undesirable terms, but reduces their overall score. */ export class BoostingQuery implements Query { /* Constructs a query that can demote search results. A negative boost. */ constructor(positiveQry: Object, negativeQry: Object, negativeBoost: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): BoostingQuery; /* Sets the query used to match documents in the positive query that will be negatively boosted. */ negative(oQuery: Object): BoostingQuery; /* Sets the negative boost value. */ negativeBoost(boost: number): BoostingQuery; /* Sets the "master" query that determines which results are returned. */ positive(oQuery: Object): BoostingQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A single-value metrics aggregation that calculates an approximate count of distinct values. Values can be extracted either from specific fields in the document or generated by a script. */ export class CardinalityAggregation implements Aggregation { /* Aggregation that calculates an approximate count of distinct values. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): CardinalityAggregation; /* The script language being used. */ lang(language: string): CardinalityAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): CardinalityAggregation; /* Allows to trade memory for accuracy, and defines a unique count below which counts are expected to be close to accurate. Above this value, counts might become a bit more fuzzy. The maximum supported value is 40000, thresholds above this number will have the same effect as a threshold of 40000. Default value depends on the number of parent aggregations that multiple create buckets (such as terms or histograms). */ precisionThreshold(num: number): CardinalityAggregation; /* Set to false to disable rehashing of values. You must have computed a hash on the client-side and stored it into your documents if you disable this. */ rehash(trueFalse: boolean): CardinalityAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): CardinalityAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A query that executes high-frequency terms in a optional sub-query to prevent slow queries due to "common" terms like stopwords. This query basically builds two queries out of the terms in the query string where low-frequency terms are added to a required boolean clause and high-frequency terms are added to an optional boolean clause. The optional clause is only executed if the required "low-frequency' clause matches. CommonTermsQuery has several advantages over stopword filtering at index or query time since a term can be "classified" based on the actual document frequency in the index and can prevent slow queries even across domains without specialized stopword files. */ export class CommonTermsQuery implements Query { /* A query that executes high-frequency terms in a optional sub-query. */ constructor(field: string, qstr: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the analyzer name used to analyze the Query object. */ analyzer(analyzer: string): CommonTermsQuery; /* Sets the boost value for documents commoning the Query. */ boost(boost: Number): CommonTermsQuery; /* Sets the maximum threshold/frequency to be considered a low frequency term. Set to a value between 0 and 1. */ cutoffFrequency(freq: Number): CommonTermsQuery; /* Enables or disables similarity coordinate scoring of documents commoning the Query. Default: false. */ disableCoord(trueFalse: string): CommonTermsQuery; /* Sets the field to query against. */ field(f: string): CommonTermsQuery; /* Sets the boolean operator to be used for high frequency terms. Default: AND */ highFreqOperator(op: string): CommonTermsQuery; /* Sets the boolean operator to be used for low frequency terms. Default: AND */ lowFreqOperator(op: string): CommonTermsQuery; /* Sets the minimum number of low freq matches that need to match in a document before that document is returned in the results. */ minimumShouldMatch(min: number): CommonTermsQuery; /* Sets the minimum number of high freq matches that need to match in a document before that document is returned in the results. */ minimumShouldMatchHighFreq(min: number): CommonTermsQuery; /* Sets the minimum number of low freq matches that need to match in a document before that document is returned in the results. */ minimumShouldMatchLowFreq(min: number): CommonTermsQuery; /* Sets the query string. */ query(qstr: string): CommonTermsQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class CompletionSuggester implements Suggest { /* A suggester that allows basic auto-complete functionality. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets analyzer used to analyze the suggest text. */ analyzer(analyzer: string): CompletionSuggester; /* Maximum edit distance (fuzziness), defaults to 1. Automatically enables fuzzy suggestions when set to any value. */ editDistance(d: number): CompletionSuggester; /* Sets the field used to generate suggestions from. */ field(field: string): CompletionSuggester; /* Enable fuzzy completions which means a can spell a word incorrectly and still get a suggestion. */ fuzzy(trueFalse: boolean): CompletionSuggester; /* Minimum length of the input before fuzzy suggestions are returned, defaults to 3. Automatically enables fuzzy suggestions when set to any value. */ minLength(m: number): CompletionSuggester; /* Minimum length of the input, which is not checked for fuzzy alternatives, defaults to 1. Automatically enables fuzzy suggestions when set to any value. */ prefixLength(l: number): CompletionSuggester; /* Sets the maximum number of suggestions to be retrieved from each individual shard. */ shardSize(s: number): CompletionSuggester; /* Sets the number of suggestions returned for each token. */ size(s: number): CompletionSuggester; /* Sets the text to get suggestions for. If not set, the global suggestion text will be used. */ text(txt: string): CompletionSuggester; /* Retrieves the internal suggest object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets if transpositions should be counted as one or two changes, defaults to true when fuzzy is enabled. Automatically enables fuzzy suggestions when set to any value. */ transpositions(trueFalse: boolean): CompletionSuggester; /* Sets all are measurements (like edit distance, transpositions and lengths) in unicode code points (actual letters) instead of bytes. Automatically enables fuzzy suggestions when set to any value. */ unicodeAware(trueFalse: boolean): CompletionSuggester; } /* A constant score query wraps another Query or Filter and returns a constant score for each result that is equal to the query boost. Note that lucene's query normalization (queryNorm) attempts to make scores between different queries comparable. It does not change the relevance of your query, but it might confuse you when you look at the score of your documents and they are not equal to the query boost value as expected. The scores were normalized by queryNorm, but maintain the same relevance. */ export class ConstantScoreQuery implements Query { /* Constructs a query where each documents returned by the internal query or filter have a constant score equal to the boost factor. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): ConstantScoreQuery; /* Enables caching of the filter. */ cache(trueFalse: boolean): ConstantScoreQuery; /* Set the cache key. */ cacheKey(k: string): ConstantScoreQuery; /* Adds the filter to apply a constant score to. */ filter(oFilter: Object): ConstantScoreQuery; /* Adds the query to apply a constant score to. */ query(oQuery: Object): ConstantScoreQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A multi-bucket aggregation similar to the histogram except it can only be applied on date values. Since dates are represented in elasticsearch internally as long values, it is possible to use the normal histogram on dates as well, though accuracy will be compromised. The reason for this is in the fact that time based intervals are not fixed (think of leap years and on the number of days in a month). For this reason, we need a special support for time based data. From a functionality perspective, this histogram supports the same features as the normal histogram. The main difference is that the interval can be specified by date/time expressions. */ export class DateHistogramAggregation implements Aggregation { /* Aggregation similar to the histogram except it can only be applied on date values. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): DateHistogramAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): DateHistogramAggregation; /* Set's the range/bounds for the histogram aggregation. Useful when you want to include buckets that might be outside the bounds of indexed documents. */ extendedBounds(min: string | number, max: string | number): DateHistogramAggregation; /* Sets the field to gather terms from. */ field(field: string): DateHistogramAggregation; /* Sets the format expression for the terms. Use for number or date formatting */ format(f: string): DateHistogramAggregation; /* Sets the histogram interval. Buckets are generated based on this interval value. */ interval(i: string): DateHistogramAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): DateHistogramAggregation; /* The script language being used. */ lang(language: string): DateHistogramAggregation; /* Only return terms that match more than a configured number of hits. */ minDocCount(num: number): DateHistogramAggregation; /* Sets order for the aggregated values. */ order(order: string, direction: string): DateHistogramAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): DateHistogramAggregation; /* Set the post-rouding offset. */ postOffset(offset: string): DateHistogramAggregation; /* Set the post-rouding date time zone. */ postZone(tz: string): DateHistogramAggregation; /* Set the pre-rouding offset. */ preOffset(offset: string): DateHistogramAggregation; /* Set the pre-rouding date time zone. */ preZone(tz: string): DateHistogramAggregation; /* Set to true to apply interval adjusts to day and above intervals. */ preZoneAdjustLargeInterval(trueFalse: boolean): DateHistogramAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): DateHistogramAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): DateHistogramAggregation; /* Set the date time zone. */ timeZone(tz: string): DateHistogramAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The DateHistogram facet works with time-based values by building a histogram across time intervals of the value field. Each value is rounded into an interval (or placed in a bucket), and statistics are provided per interval/bucket (count and total). Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class DateHistogramFacet implements Facet { /* A facet which returns the N most frequent terms within a collection or set of collections. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): DateHistogramFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): DateHistogramFacet; /* The date histogram works on numeric values (since time is stored in milliseconds since the epoch in UTC). But, sometimes, systems will store a different resolution (like seconds since UTC) in a numeric field. The factor parameter can be used to change the value in the field to milliseconds to actual do the relevant rounding, and then be applied again to get to the original unit. For example, when storing in a numeric field seconds resolution, the factor can be set to 1000. */ factor(f: number): DateHistogramFacet; /* Sets the field to be used to construct the this facet. */ field(fieldName: string): DateHistogramFacet; /* Computes values across the entire index */ global(trueFalse: boolean): DateHistogramFacet; /* Sets the bucket interval used to calculate the distribution. */ interval(timeInterval: string): DateHistogramFacet; /* Allows you to specify a different key field to be used to group intervals. */ keyField(fieldName: string): DateHistogramFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): DateHistogramFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): DateHistogramFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): DateHistogramFacet; /* Sets the type of ordering that will be performed on the date buckets. Valid values are: time - the default, sort by the buckets start time in milliseconds. count - sort by the number of items in the bucket total - sort by the sum/total of the items in the bucket */ order(o: string): DateHistogramFacet; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): DateHistogramFacet; /* Set's a specific post-rounding offset. Format is 1d, 1h, etc. */ postOffset(offset: string): DateHistogramFacet; /* By default, time values are stored in UTC format. This method allows users to set a time zone value that is then used to compute intervals after rounding on the interval value. The value is an offset from UTC. The tz offset value is simply added to the resulting bucket's date value. For example, to use EST you would set the value to -5. */ postZone(tz: number): DateHistogramFacet; /* Set's a specific pre-rounding offset. Format is 1d, 1h, etc. */ preOffset(offset: string): DateHistogramFacet; /* By default, time values are stored in UTC format. This method allows users to set a time zone value that is then used to compute intervals before rounding on the interval value. The value is an offset from UTC. For example, to use EST you would set the value to -5. */ preZone(tz: number): DateHistogramFacet; /* Enables large date interval conversions (day and up). Set to true to enable and then set the interval to an interval greater than a day. */ preZoneAdjustLargeInterval(trueFalse: boolean): DateHistogramFacet; /* Computes values across the the specified scope */ scope(scope: string): DateHistogramFacet; /* By default, time values are stored in UTC format. This method allows users to set a time zone value that is then used to compute intervals before rounding on the interval value. Equalivent to preZone. Use preZone if possible. The value is an offset from UTC. For example, to use EST you would set the value to -5. */ timeZone(tz: number): DateHistogramFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Allows you to specify a different value field to aggrerate over. */ valueField(fieldName: string): DateHistogramFacet; /* Allows you modify the value field using a script. The modified value is then used to compute the statistical data. */ valueScript(scriptCode: string): DateHistogramFacet; } /* A range aggregation that is dedicated for date values. The main difference between this aggregation and the normal range aggregation is that the from and to values can be expressed in Date Math expressions, and it is also possible to specify a date format by which the from and to response fields will be returned. Note that this aggregration includes the from value and excludes the to value for each range. Note that this aggregration includes the from value and excludes the to value for each range. */ export class DateRangeAggregation implements Aggregation { /* Aggregation that is dedicated for date value ranges. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): DateRangeAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): DateRangeAggregation; /* Sets the field to gather terms from. */ field(field: string): DateRangeAggregation; /* Sets the date format expression. */ format(f: string): DateRangeAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): DateRangeAggregation; /* The script language being used. */ lang(language: string): DateRangeAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): DateRangeAggregation; /* Adds a range to the list of exsiting range expressions. */ range(from: string, to: string, key: string): DateRangeAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): DateRangeAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): DateRangeAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Decay functions score a document with a function that decays depending on the distance of a numeric field value of the document from a user given origin. This is similar to a range query, but with smooth edges instead of boxes. Supported decay functions are: linear, exp, and gauss. */ export class DecayScoreFunction implements ScoreFunction { /* Score a document with a function that decays depending on the distance of a numeric field value of the document from given origin. */ constructor(field: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the decay value which defines how documents are scored at the distance given at scale. */ decay(d: number): DecayScoreFunction; /* Use the exp decay function. Exponential decay. */ exp(): DecayScoreFunction; /* Sets the fields to run the decay function against. */ field(f: string): DecayScoreFunction; /* Adds a filter whose matching documents will have the score function applied. */ filter(oFilter: Filter): DecayScoreFunction; /* Use the gauss decay function. Normal decay. */ gauss(): DecayScoreFunction; /* Use the linear decay function. Linear decay. */ linear(): DecayScoreFunction; /* Sets the decay offset. The decay function will only compute a the decay function for documents with a distance greater that the defined offset. The default is 0. */ offset(o: string): DecayScoreFunction; /* Sets the origin which is the “central point” from which the distance is calculated. */ origin(o: string): DecayScoreFunction; /* Sets the scale/rate of decay. */ scale(s: string): DecayScoreFunction; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* DirectGenerator is a candidate generator for PhraseSuggester. It generates terms based on edit distance and operators much like the TermSuggester. */ export class DirectGenerator implements Generator { /* A candidate generator that generates terms based on edit distance. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the accuracy. How similar the suggested terms at least need to be compared to the original suggest text. */ accuracy(a: number): DirectGenerator; /* Sets the field used to generate suggestions from. */ field(field: string): DirectGenerator; /* Sets the maximum edit distance candidate suggestions can have in order to be considered as a suggestion. */ maxEdits(max: number): DirectGenerator; /* The factor that is used to multiply with the size in order to inspect more candidate suggestions. */ maxInspections(max: number): DirectGenerator; /* Sets a maximum threshold in number of documents a suggest text token can exist in order to be corrected. */ maxTermFreq(max: number): DirectGenerator; /* Sets a minimal threshold of the number of documents a suggested term should appear in. */ minDocFreq(min: number): DirectGenerator; /* Sets the minimum length a suggest text term must have in order to be corrected. */ minWordLen(len: number): DirectGenerator; /* Sets an analyzer that is applied to each of the generated tokens before they are passed to the actual phrase scorer. */ postFilter(analyzer: string): DirectGenerator; /* Sets an analyzer that is applied to each of the tokens passed to this generator. The analyzer is applied to the original tokens, not the generated tokens. */ preFilter(analyzer: string): DirectGenerator; /* Sets the number of suggestions returned for each token. */ size(s: number): DirectGenerator; /* Sets the sort mode. Valid values are: score - Sort by score first, then document frequency, and then the term itself frequency - Sort by document frequency first, then simlarity score and then the term itself */ sort(s: string): DirectGenerator; /* Sets what string distance implementation to use for comparing how similar suggested terms are. Valid values are: internal - based on damerau_levenshtein but but highly optimized for comparing string distance for terms inside the index damerau_levenshtein - String distance algorithm based on Damerau-Levenshtein algorithm levenstein - String distance algorithm based on Levenstein edit distance algorithm jarowinkler - String distance algorithm based on Jaro-Winkler algorithm ngram - String distance algorithm based on character n-grams */ stringDistance(s: string): DirectGenerator; /* Sets the suggest mode. Valid values are: missing - Only suggest terms in the suggest text that aren't in the index popular - Only suggest suggestions that occur in more docs then the original suggest text term always - Suggest any matching suggestions based on terms in the suggest text */ suggestMode(m: string): DirectGenerator; /* Retrieves the internal generator object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class DirectSettingsMixin { /* Sets the accuracy. How similar the suggested terms at least need to be compared to the original suggest text. */ accuracy(a: number): DirectSettingsMixin; /* Sets the maximum edit distance candidate suggestions can have in order to be considered as a suggestion. */ maxEdits(max: number): DirectSettingsMixin; /* The factor that is used to multiply with the size in order to inspect more candidate suggestions. */ maxInspections(max: number): DirectSettingsMixin; /* Sets a maximum threshold in number of documents a suggest text token can exist in order to be corrected. */ maxTermFreq(max: number): DirectSettingsMixin; /* Sets a minimal threshold of the number of documents a suggested term should appear in. */ minDocFreq(min: number): DirectSettingsMixin; /* Sets the minimum length a suggest text term must have in order to be corrected. */ minWordLen(len: number): DirectSettingsMixin; /* Sets the number of minimal prefix characters that must match in order be a candidate suggestion. */ prefixLen(len: number): DirectSettingsMixin; /* Sets the sort mode. Valid values are: score - Sort by score first, then document frequency, and then the term itself frequency - Sort by document frequency first, then simlarity score and then the term itself */ sort(s: string): DirectSettingsMixin; /* Sets what string distance implementation to use for comparing how similar suggested terms are. Valid values are: internal - based on damerau_levenshtein but but highly optimized for comparing string distance for terms inside the index damerau_levenshtein - String distance algorithm based on Damerau-Levenshtein algorithm levenstein - String distance algorithm based on Levenstein edit distance algorithm jarowinkler - String distance algorithm based on Jaro-Winkler algorithm ngram - String distance algorithm based on character n-grams */ stringDistance(s: string): DirectSettingsMixin; /* Sets the suggest mode. Valid values are: missing - Only suggest terms in the suggest text that aren't in the index popular - Only suggest suggestions that occur in more docs then the original suggest text term always - Suggest any matching suggestions based on terms in the suggest text */ suggestMode(m: string): DirectSettingsMixin; } /* A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. */ export class DisMaxQuery implements Query { /* A query that generates the union of documents produced by its subqueries such as termQuerys, phraseQuerys, boolQuerys, etc. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): DisMaxQuery; /* Updates the queries. If passed a single Query, it is added to the list of existing queries. If passed an array of Queries, it replaces all existing values. */ queries(qs: Query | Query[]): DisMaxQuery; /* The tie breaker value. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields. Default: 0.0. */ tieBreaker(tieBreaker: number): DisMaxQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* An existsFilter matches documents where the specified field is present and the field contains a legitimate value. */ export class ExistsFilter implements Filter { /* Filters documents where a specified field exists and contains a value. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): ExistsFilter; /* Sets the cache key. */ cacheKey(key: string): ExistsFilter; /* Sets the field to check for missing values. */ field(name: string): ExistsFilter; /* Sets the filter name. */ name(name: string): ExistsFilter; /* Returns the filter object. */ toJSON(): ExistsFilter; } /* A multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. The extended_stats aggregations is an extended version of the StatsAggregation, where additional metrics are added such as sum_of_squares, variance and std_deviation. */ export class ExtendedStatsAggregation implements Aggregation { /* Aggregation that computes extra stats over numeric values extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): ExtendedStatsAggregation; /* The script language being used. */ lang(language: string): ExtendedStatsAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): ExtendedStatsAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): ExtendedStatsAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): ExtendedStatsAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class FacetMixin { /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): FacetMixin; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): FacetMixin; /* Computes values across the entire index */ global(trueFalse: boolean): FacetMixin; /* Sets the mode the facet will use. collector post */ mode(m: string): FacetMixin; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): FacetMixin; /* Computes values across the the specified scope */ scope(scope: string): FacetMixin; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about their search field. That is, the masked SpanQuery will function as normal, but when asked for the field it queries against, it will return the value specified as the masked field vs. the real field used in the wrapped span query. */ export class FieldMaskingSpanQuery implements Query { /* Wraps a SpanQuery and hides the real field being searched across. */ constructor(spanQry: Query, field: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): FieldMaskingSpanQuery; /* Sets the value of the "masked" field. */ field(f: string): FieldMaskingSpanQuery; /* Sets the span query to wrap. */ query(spanQuery: Query): FieldMaskingSpanQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Defines a single bucket of all the documents in the current document set context that match a specified filter. Often this will be used to narrow down the current aggregation context to a specific set of documents. */ export class FilterAggregation implements Aggregation { /* Defines a single bucket of all the documents that match a given filter. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): FilterAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): FilterAggregation; /* Sets the filter to be used for this aggregation. */ filter(oFilter: Filter): FilterAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Filter queries allow you to restrict the results returned by a query. There are several different types of filters that can be applied (see filter module). A filterQuery takes a Query and a Filter object as arguments and constructs a new Query that is then used for the search. */ export class FilteredQuery implements Query { /* A query that applies a filter to the results of another query. */ constructor(someQuery: Object, someFilter: Object); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): FilteredQuery; /* Enables caching of the filter. */ cache(trueFalse: boolean): FilteredQuery; /* Set the cache key. */ cacheKey(k: string): FilteredQuery; /* Adds the filter to apply a constant score to. */ filter(oFilter: Object): FilteredQuery; /* Adds the query to apply a constant score to. */ query(oQuery: Object): FilteredQuery; /* Sets the filter strategy. The strategy defines how the filter is applied during document collection. Valid values are: query_first - advance query scorer first then filter random_access_random - random access filter leap_frog - query scorer and filter "leap-frog", query goes first leap_frog_filter_first - same as leap_frog, but filter goes first random_access_N - replace N with integer, same as random access except you can specify a custom threshold This is an advanced setting, use with care. */ strategy(strategy: string): FilteredQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The FilterFacet allows you to specify any valid Filter and have the number of matching hits returned as the value. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class FilterFacet implements Facet { /* A facet that return a count of the hits matching the given filter. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): FilterFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): FilterFacet; /* Sets the filter to be used for this facet. */ filter(oFilter: Object): FilterFacet; /* Computes values across the entire index */ global(trueFalse: boolean): FilterFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): FilterFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): FilterFacet; /* Computes values across the the specified scope */ scope(scope: string): FilterFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class FilterMixin { /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): FilterMixin; /* Sets the cache key. */ cacheKey(key: string): FilterMixin; /* Sets the filter name. */ name(name: string): FilterMixin; /* Returns the filter object. */ toJSON(): FilterMixin; } /* The function_score allows you to modify the score of documents that are retrieved by a query. This can be useful if, for example, a score function is computationally expensive and it is sufficient to compute the score on a filtered set of documents. */ export class FunctionScoreQuery implements Query { /* A query that allows you to modify the score of matching documents. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): FunctionScoreQuery; /* Set the setermines how the new calculated score is combined with the score from the original query. Valid values are: multiply, replace, sum, avg, max, and min. */ boostMode(mode: string): FunctionScoreQuery; /* Set the source filter. */ filter(oFilter: Filter): FunctionScoreQuery; /* Add a single score function to the list of existing functions. */ //function (func: ScoreFunction): FunctionScoreQuery; /* Sets the score functions. Replaces any existing score functions. */ functions(funcs: ScoreFunction[]): FunctionScoreQuery; /* Set the source query. */ query(oQuery: Query): FunctionScoreQuery; /* Set the scoring mode which specifies how the computed scores are combined. Valid values are: avg, max, min, sum, multiply, and first. */ scoreMode(mode: string): FunctionScoreQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The fuzzy_like_this_field query is the same as the fuzzy_like_this query, except that it runs against a single field. It provides nicer query DSL over the generic fuzzy_like_this query, and support typed fields query (automatically wraps typed fields with type filter to match only on the specific type). Fuzzifies ALL terms provided as strings and then picks the best n differentiating terms. In effect this mixes the behaviour of FuzzyQuery and MoreLikeThis but with special consideration of fuzzy scoring factors. This generally produces good results for queries where users may provide details in a number of fields and have no knowledge of boolean query syntax and also want a degree of fuzzy matching and a fast query. For each source term the fuzzy variants are held in a BooleanQuery with no coord factor (because we are not looking for matches on multiple variants in any one doc). Additionally, a specialized TermQuery is used for variants and does not use that variant term’s IDF because this would favour rarer terms eg misspellings. Instead, all variants use the same IDF ranking (the one for the source query term) and this is factored into the variant’s boost. If the source query term does not exist in the index the average IDF of the variants is used. */ export class FuzzyLikeThisFieldQuery implements Query { /* Constructs a query where each documents returned are “like” provided text */ constructor(field: string, likeText: string); /* The type of ejs object. For internal use only. */ _type(): string; /* The analyzer that will be used to analyze the text. Defaults to the analyzer associated with the field. */ analyzer(analyzerName: string): FuzzyLikeThisFieldQuery; /* Sets the boost value of the Query. */ boost(boost: number): FuzzyLikeThisFieldQuery; /* Should the Query fail when an unsupported field is specified. Defaults to true. */ failOnUnsupportedField(trueFalse: boolean): FuzzyLikeThisFieldQuery; /* The field to run the query against. */ field(f: string): FuzzyLikeThisFieldQuery; /* Should term frequency be ignored. Defaults to false. */ ignoreTf(trueFalse: boolean): FuzzyLikeThisFieldQuery; /* The text to find documents like */ likeText(s: string): FuzzyLikeThisFieldQuery; /* The maximum number of query terms that will be included in any generated query. Defaults to 25. */ maxQueryTerms(max: number): FuzzyLikeThisFieldQuery; /* The minimum similarity of the term variants. Defaults to 0.5. */ minSimilarity(min: number): FuzzyLikeThisFieldQuery; /* Length of required common prefix on variant terms. Defaults to 0.. */ prefixLength(len: number): FuzzyLikeThisFieldQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Fuzzy like this query find documents that are “like” provided text by running it against one or more fields. Fuzzifies ALL terms provided as strings and then picks the best n differentiating terms. In effect this mixes the behaviour of FuzzyQuery and MoreLikeThis but with special consideration of fuzzy scoring factors. This generally produces good results for queries where users may provide details in a number of fields and have no knowledge of boolean query syntax and also want a degree of fuzzy matching and a fast query. For each source term the fuzzy variants are held in a BooleanQuery with no coord factor (because we are not looking for matches on multiple variants in any one doc). Additionally, a specialized TermQuery is used for variants and does not use that variant term’s IDF because this would favour rarer terms eg misspellings. Instead, all variants use the same IDF ranking (the one for the source query term) and this is factored into the variant’s boost. If the source query term does not exist in the index the average IDF of the variants is used. */ export class FuzzyLikeThisQuery implements Query { /* Constructs a query where each documents returned are “like” provided text */ constructor(likeText: string); /* The type of ejs object. For internal use only. */ _type(): string; /* The analyzer that will be used to analyze the text. Defaults to the analyzer associated with the field. */ analyzer(analyzerName: string): FuzzyLikeThisQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: number): FuzzyLikeThisQuery; /* Should the Query fail when an unsupported field is specified. Defaults to true. */ failOnUnsupportedField(trueFalse: boolean): FuzzyLikeThisQuery; /* The fields to run the query against. If you call with a single field, it is added to the existing list of fields. If called with an array of field names, it replaces any existing values with the new array. */ fields(f: string | string[]): FuzzyLikeThisQuery; /* Should term frequency be ignored. Defaults to false. */ ignoreTf(trueFalse: boolean): FuzzyLikeThisQuery; /* The text to find documents like */ likeText(s: string): FuzzyLikeThisQuery; /* The maximum number of query terms that will be included in any generated query. Defaults to 25. */ maxQueryTerms(max: number): FuzzyLikeThisQuery; /* The minimum similarity of the term variants. Defaults to 0.5. */ minSimilarity(min: number): FuzzyLikeThisQuery; /* Length of required common prefix on variant terms. Defaults to 0.. */ prefixLength(len: number): FuzzyLikeThisQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A fuzzy search query based on the Damerau-Levenshtein (optimal string alignment) algorithm, though you can explicitly choose classic Levenshtein by passing false to the transpositions parameter./p> fuzzy query on a numeric field will result in a range query “around” the value using the min_similarity value. As an example, if you perform a fuzzy query against a field value of "12" with a min similarity setting of "2", the query will search for values between "10" and "14". */ export class FuzzyQuery implements Query { /* Constructs a query where each documents returned are “like” provided text */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value of the Query. */ boost(boost: number): FuzzyQuery; /* The field to run the query against. */ field(f: string): FuzzyQuery; /* The maximum number of query terms that will be included in any generated query. Defaults to 50. */ maxExpansions(max: number): FuzzyQuery; /* The minimum similarity of the term variants. Defaults to 0.5. */ minSimilarity(min: number): FuzzyQuery; /* Length of required common prefix on variant terms. Defaults to 0. */ prefixLength(len: number): FuzzyQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): FuzzyQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Set to false to use classic Levenshtein edit distance. */ transpositions(trueFalse: boolean): FuzzyQuery; /* The query text to fuzzify. */ value(s: string): FuzzyQuery; } /* A filter that restricts matched results/docs to a geographic bounding box described by the specified lon and lat coordinates. The format conforms with the GeoJSON specification. */ export class GeoBboxFilter implements Filter { /* Filter results to those which are contained within the defined bounding box. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the bottom-right coordinate of the bounding box */ bottomRight(p: GeoPoint): GeoBboxFilter; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): GeoBboxFilter; /* Sets the cache key. */ cacheKey(key: string): GeoBboxFilter; /* Sets the fields to filter against. */ field(f: string): GeoBboxFilter; /* Sets the filter name. */ name(name: string): GeoBboxFilter; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range */ normalize(trueFalse: string): GeoBboxFilter; /* Returns the filter object. */ toJSON(): GeoBboxFilter; /* Sets the top-left coordinate of the bounding box */ topLeft(p: GeoPoint): GeoBboxFilter; /* Sets the type of the bounding box execution. Valid values are "memory" and "indexed". Default is memory. */ type(type: string): GeoBboxFilter; } /* A multi-bucket aggregation that works on geo_point fields and conceptually works very similar to the range aggregation. The user can define a point of origin and a set of distance range buckets. The aggregation evaluate the distance of each document value from the origin point and determines the buckets it belongs to based on the ranges (a document belongs to a bucket if the distance between the document and the origin falls within the distance range of the bucket). */ export class GeoDistanceAggregation implements Aggregation { /* Aggregation that works on geo_point fields and conceptually works very similar to the range aggregation. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): GeoDistanceAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): GeoDistanceAggregation; /* Sets the point of origin from where distances will be measured. Same as origin. */ center(p: GeoPoint): GeoDistanceAggregation; /* How to compute the distance. Valid values are: plane, arc, sloppy_arc, and factor. */ distanceType(type: string): GeoDistanceAggregation; /* Sets the field to gather terms from. */ field(field: string): GeoDistanceAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): GeoDistanceAggregation; /* Sets the point of origin from where distances will be measured. */ origin(p: GeoPoint): GeoDistanceAggregation; /* Sets the point of origin from where distances will be measured. Same as origin. */ point(p: GeoPoint): GeoDistanceAggregation; /* Adds a range to the list of exsiting range expressions. */ range(from: string, to: string, key: string): GeoDistanceAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the distance unit. Valid values are: in, yd, ft, km, NM, mm, cm, mi, and m. */ unit(unit: string): GeoDistanceAggregation; } /* The geoDistanceFacet facet provides information over a range of distances from a provided point. This includes the number of hits that fall within each range, along with aggregate information (like total). Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class GeoDistanceFacet implements Facet { /* A facet which provides information over a range of distances from a provided point. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Adds a new bounded range. */ addRange(from: Number, to: Number): GeoDistanceFacet; /* Adds a new unbounded lower limit. */ addUnboundedFrom(from: Number): GeoDistanceFacet; /* Adds a new unbounded upper limit. */ addUnboundedTo(to: Number): GeoDistanceFacet; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): GeoDistanceFacet; /* How to compute the distance. Can either be arc (better precision) or plane (faster). Defaults to arc. */ distanceType(type: string): GeoDistanceFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): GeoDistanceFacet; /* Sets the document field containing the geo-coordinate to be used to calculate the distance. Defaults to "location". */ field(fieldName: string): GeoDistanceFacet; /* Computes values across the entire index */ global(trueFalse: boolean): GeoDistanceFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): GeoDistanceFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): GeoDistanceFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): GeoDistanceFacet; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range */ normalize(trueFalse: string): GeoDistanceFacet; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): GeoDistanceFacet; /* Sets the point of origin from where distances will be measured. */ point(p: GeoPoint): GeoDistanceFacet; /* Computes values across the the specified scope */ scope(scope: string): GeoDistanceFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the distance unit. Valid values are "mi" for miles or "km" for kilometers. Defaults to "km". */ unit(unit: string): GeoDistanceFacet; /* Allows you to specify a different value field to aggrerate over. */ valueField(fieldName: string): GeoDistanceFacet; /* Allows you modify the value field using a script. The modified value is then used to compute the statistical data. */ valueScript(scriptCode: string): GeoDistanceFacet; } /* A filter that restricts matched results/docs to a given distance from the point of origin. The format conforms with the GeoJSON specification. */ export class GeoDistanceFilter implements Filter { /* Filter results to those which fall within the given distance of the point of origin. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): GeoDistanceFilter; /* Sets the cache key. */ cacheKey(key: string): GeoDistanceFilter; /* Sets the numeric distance to be used. The distance can be a numeric value, and then the unit (either mi or km can be set) controlling the unit. Or a single string with the unit as well. */ distance(numericDistance: Number): GeoDistanceFilter; /* How to compute the distance. Can either be arc (better precision) or plane (faster). Defaults to arc. */ distanceType(type: string): GeoDistanceFilter; /* Sets the fields to filter against. */ field(f: string): GeoDistanceFilter; /* Sets the filter name. */ name(name: string): GeoDistanceFilter; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range */ normalize(trueFalse: string): GeoDistanceFilter; /* Will an optimization of using first a bounding box check will be used. Defaults to memory which will do in memory checks. Can also have values of indexed to use indexed value check, or none which disables bounding box optimization. */ optimizeBbox(t: string): GeoDistanceFilter; /* Sets the point of origin in which distance will be measured from */ point(p: GeoPoint): GeoDistanceFilter; /* Returns the filter object. */ toJSON(): GeoDistanceFilter; /* Sets the distance unit. Valid values are "mi" for miles or "km" for kilometers. Defaults to "km". */ unit(unit: string): GeoDistanceFilter; } /* A filter that restricts matched results/docs to a given distance range from the point of origin. The format conforms with the GeoJSON specification. */ export class GeoDistanceRangeFilter implements Filter { /* Filter results to those which fall within the given distance range of the point of origin. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): GeoDistanceRangeFilter; /* Sets the cache key. */ cacheKey(key: string): GeoDistanceRangeFilter; /* How to compute the distance. Can either be arc (better precision) or plane (faster). Defaults to arc. */ distanceType(type: string): GeoDistanceRangeFilter; /* Sets the fields to filter against. */ field(f: string): GeoDistanceRangeFilter; /* Sets the start point of the distance range */ from(numericDistance: Number): GeoDistanceRangeFilter; /* Greater than value. Same as setting from to the value, and include_lower to false, */ gt(val: Number): GeoDistanceRangeFilter; /* Greater than or equal to value. Same as setting from to the value, and include_lower to true. */ gte(val: Number): GeoDistanceRangeFilter; /* Should the first from (if set) be inclusive or not. Defaults to true */ includeLower(trueFalse: boolean): GeoDistanceRangeFilter; /* Should the last to (if set) be inclusive or not. Defaults to true. */ includeUpper(trueFalse: boolean): GeoDistanceRangeFilter; /* Less than value. Same as setting to to the value, and include_upper to false. */ lt(val: Number): GeoDistanceRangeFilter; /* Less than or equal to value. Same as setting to to the value, and include_upper to true. */ lte(val: Number): GeoDistanceRangeFilter; /* Sets the filter name. */ name(name: string): GeoDistanceRangeFilter; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range */ normalize(trueFalse: string): GeoDistanceRangeFilter; /* Will an optimization of using first a bounding box check will be used. Defaults to memory which will do in memory checks. Can also have values of indexed to use indexed value check, or none which disables bounding box optimization. */ optimizeBbox(t: string): GeoDistanceRangeFilter; /* Sets the point of origin in which distance will be measured from */ point(p: GeoPoint): GeoDistanceRangeFilter; /* Sets the end point of the distance range */ to(numericDistance: Number): GeoDistanceRangeFilter; /* Returns the filter object. */ toJSON(): GeoDistanceRangeFilter; /* Sets the distance unit. Valid values are "mi" for miles or "km" for kilometers. Defaults to "km". */ unit(unit: string): GeoDistanceRangeFilter; } /* A multi-bucket aggregation that works on geo_point fields and groups points into buckets that represent cells in a grid. The resulting grid can be sparse and only contains cells that have matching data. Each cell is labeled using a geohash which is of user-definable precision. */ export class GeoHashGridAggregation implements Aggregation { /* Aggregation that works on geo_point fields and groups points into buckets that represent cells in a grid. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): GeoHashGridAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): GeoHashGridAggregation; /* Sets the geo field to perform calculations from. */ field(field: string): GeoHashGridAggregation; /* Sets the Geo Hash precision. The precision value can be between 1 and 12 where 12 is the highest precision. */ precision(p: number): GeoHashGridAggregation; /* Determines how many geohash_grid the coordinating node will request from each shard. */ shardSize(shardSize: number): GeoHashGridAggregation; /* Sets the number of aggregation entries that will be returned. */ size(size: number): GeoHashGridAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A GeoPoint object that can be used in queries and filters that take a GeoPoint. GeoPoint supports various input formats. See http://www.elasticsearch.org/guide/reference/mapping/geo-point-type.html */ export class GeoPoint implements Geo { /* Defines a point */ constructor(p: any[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the GeoPoint from an array point. The array must contain only 2 values. The first value is the lat and the 2nd value is the lon. Example: [41.12, -71.34] */ array(a: any[]): GeoPoint; /* Sets the GeoPoint as a GeoHash. The hash is a string of alpha-numeric characters with a precision length that defaults to 12. Example: "drm3btev3e86" */ geohash(hash: string, precision: number): GeoPoint; /* Sets the GeoPoint as properties on an object. The object must have a 'lat' and 'lon' or a 'geohash' property. Example: {lat: 41.12, lon: -71.34} or {geohash: "drm3btev3e86"} */ properties(obj: Object): GeoPoint; /* Sets the GeoPoint as a string. The format is "lat,lon". Example: "41.12,-71.34" */ string(s: string): GeoPoint; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A filter for locating documents that fall within a polygon of points. Simply provide a lon/lat for each document as a Geo Point type. The format conforms with the GeoJSON specification. */ export class GeoPolygonFilter { /* Filter results to those which are contained within the polygon of points. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): GeoPolygonFilter; /* Sets the cache key. */ cacheKey(key: string): GeoPolygonFilter; /* Sets the fields to filter against. */ field(f: string): GeoPolygonFilter; /* Sets the filter name. */ name(name: string): GeoPolygonFilter; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range */ normalize(trueFalse: string): GeoPolygonFilter; /* Sets a series of points that represent a polygon. If passed a single GeoPoint object, it is added to the current list of points. If passed an array of GeoPoint objects it replaces all current values. */ points(pointsArray: any[]): GeoPolygonFilter; /* Returns the filter object. */ toJSON(): GeoPolygonFilter; } /* Efficient filtering of documents containing shapes indexed using the geo_shape type. Much like the geo_shape type, the geo_shape filter uses a grid square representation of the filter shape to find those documents which have shapes that relate to the filter shape in a specified way. In order to do this, the field being queried must be of geo_shape type. The filter will use the same PrefixTree configuration as defined for the field. */ export class GeoShapeFilter implements Filter { /* A Filter to find documents with a geo_shapes matching a specific shape. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): GeoShapeFilter; /* Sets the cache key. */ cacheKey(key: string): GeoShapeFilter; /* Sets the field to filter against. */ field(f: string): GeoShapeFilter; /* Sets the indexed shape. Use this if you already have shape definitions already indexed. */ indexedShape(indexedShape: string): GeoShapeFilter; /* Sets the filter name. */ name(name: string): GeoShapeFilter; /* Sets the shape relation type. A relationship between a Query Shape and indexed Shapes that will be used to determine if a Document should be matched or not. Valid values are: intersects, disjoint, and within. */ relation(indexedShape: string): GeoShapeFilter; /* Sets the shape */ shape(shape: string): GeoShapeFilter; /* Sets the spatial strategy. Valid values are: recursive - default, recursively traverse nodes in the spatial prefix tree. This strategy has support for searching non-point shapes. term - uses a large TermsFilter on each node in the spatial prefix tree. It only supports the search of indexed Point shapes. This is an advanced setting, use with care. */ strategy(strategy: string): GeoShapeFilter; /* Returns the filter object. */ toJSON(): GeoShapeFilter; } /* Efficient querying of documents containing shapes indexed using the geo_shape type. Much like the geo_shape type, the geo_shape query uses a grid square representation of the query shape to find those documents which have shapes that relate to the query shape in a specified way. In order to do this, the field being queried must be of geo_shape type. The query will use the same PrefixTree configuration as defined for the field. */ export class GeoShapeQuery implements Query { /* A Query to find documents with a geo_shapes matching a specific shape. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: Number): GeoShapeQuery; /* Sets the field to query against. */ field(f: string): GeoShapeQuery; /* Sets the indexed shape. Use this if you already have shape definitions already indexed. */ indexedShape(indexedShape: string): GeoShapeQuery; /* Sets the shape relation type. A relationship between a Query Shape and indexed Shapes that will be used to determine if a Document should be matched or not. Valid values are: intersects, disjoint, and within. */ relation(indexedShape: string): GeoShapeQuery; /* Sets the shape */ shape(shape: string): GeoShapeQuery; /* Sets the spatial strategy. Valid values are: recursive - default, recursively traverse nodes in the spatial prefix tree. This strategy has support for searching non-point shapes. term - uses a large TermsFilter on each node in the spatial prefix tree. It only supports the search of indexed Point shapes. This is an advanced setting, use with care. */ strategy(strategy: string): GeoShapeQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Defines a single bucket of all the documents within the search execution context. This context is defined by the indices and the document types you’re searching on, but is not influenced by the search query itself. */ export class GlobalAggregation implements Aggregation { /* Defines a single bucket of all the documents within the search context. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): GlobalAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): GlobalAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The has_child filter results in parent documents that have child docs matching the query being returned. */ export class HasChildFilter implements Filter { /* Returns results that have child documents matching the filter. */ constructor(qry: Object, type: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): HasChildFilter; /* Sets the cache key. */ cacheKey(key: string): HasChildFilter; /* Sets the filter */ filter(f: Query): HasChildFilter; /* Sets the filter name. */ name(name: string): HasChildFilter; /* Sets the query */ query(q: Query): HasChildFilter; /* Sets the scope of the filter. A scope allows to run facets on the same scope name that will work against the child documents. */ scope(s: string): HasChildFilter; /* Sets the cutoff value to short circuit processing. */ shortCircuitCutoff(cutoff: number): HasChildFilter; /* Returns the filter object. */ toJSON(): HasChildFilter; /* Sets the child document type to search against */ type(t: string): HasChildFilter; } /* The has_child query works the same as the has_child filter, by automatically wrapping the filter with a constant_score. Results in parent documents that have child docs matching the query being returned. */ export class HasChildQuery implements Query { /* Returns results that have child documents matching the query. */ constructor(qry: Object, type: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): HasChildQuery; /* Sets the query */ query(q: Object): HasChildQuery; /* Sets the scope of the query. A scope allows to run facets on the same scope name that will work against the child documents. */ scope(s: string): HasChildQuery; /* Sets the scoring method. Valid values are: none - the default, no scoring max - the highest score of all matched child documents is used sum - the sum the all the matched child documents is used avg - the average of all matched child documents is used */ scoreMode(s: string): HasChildQuery; /* Sets the scoring method. Valid values are: none - the default, no scoring max - the highest score of all matched child documents is used sum - the sum the all the matched child documents is used avg - the average of all matched child documents is used */ scoreType(s: string): HasChildQuery; /* Sets the cutoff value to short circuit processing. */ shortCircuitCutoff(cutoff: number): HasChildQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the child document type to search against */ type(t: string): HasChildQuery; } /* The has_parent results in child documents that have parent docs matching the query being returned. */ export class HasParentFilter implements Filter { /* Returns results that have parent documents matching the filter. */ constructor(qry: Object, parentType: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): HasParentFilter; /* Sets the cache key. */ cacheKey(key: string): HasParentFilter; /* Sets the filter */ filter(f: Object): HasParentFilter; /* Sets the filter name. */ name(name: string): HasParentFilter; /* Sets the child document type to search against */ parentType(t: string): HasParentFilter; /* Sets the query */ query(q: Object): HasParentFilter; /* Sets the scope of the filter. A scope allows to run facets on the same scope name that will work against the parent documents. */ scope(s: string): HasParentFilter; /* Returns the filter object. */ toJSON(): HasParentFilter; } /* The has_parent query works the same as the has_parent filter, by automatically wrapping the filter with a constant_score. Results in child documents that have parent docs matching the query being returned. */ export class HasParentQuery implements Query { /* Returns results that have parent documents matching the query. */ constructor(qry: Object, parentType: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): HasParentQuery; /* Sets the child document type to search against */ parentType(t: string): HasParentQuery; /* Sets the query */ query(q: Object): HasParentQuery; /* Sets the scope of the query. A scope allows to run facets on the same scope name that will work against the parent documents. */ scope(s: string): HasParentQuery; /* Sets the scoring method. Valid values are: none - the default, no scoring score - the score of the parent is used in all child documents. */ scoreMode(s: string): HasParentQuery; /* Sets the scoring method. Valid values are: none - the default, no scoring score - the score of the parent is used in all child documents. */ scoreType(s: string): HasParentQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Allows to highlight search results on one or more fields. In order to perform highlighting, the actual content of the field is required. If the field in question is stored (has store set to yes in the mapping), it will be used, otherwise, the actual _source will be loaded and the relevant field will be extracted from it. If no term_vector information is provided (by setting it to with_positions_offsets in the mapping), then the plain highlighter will be used. If it is provided, then the fast vector highlighter will be used. When term vectors are available, highlighting will be performed faster at the cost of bigger index size. See http://www.elasticsearch.org/guide/reference/api/search/highlighting.html */ export class Highlight { /* Allows to highlight search results on one or more fields. */ constructor(fields: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Set's the boundary characters. When highlighting a field that is mapped with term vectors, boundary_chars can be configured to define what constitutes a boundary for highlighting. It’s a single string with each boundary character defined in it. You can apply the option to a specific field by passing the field name in to the oField parameter. It defaults to ".,!? \t\n". */ boundaryChars(charStr: string, oField: string): Highlight; /* Sets the max number of characters to scan while looking for the start of a boundary character. You can apply the option to a specific field by passing the field name in to the oField parameter. Default: 20 */ boundaryMaxScan(cnt: number, oField: string): Highlight; /* Sets highlight encoder. Valid values are: default - the default, no encoding html - to encode html characters if you use html tags */ encoder(e: string): Highlight; /* Allows you to set the fields that will be highlighted. You can specify a single field or an array of fields. All fields are added to the current list of fields. */ fields(vals: string | string[]): Highlight; /* Sets the fragmenter type. You can apply the option to a specific field by passing the field name in to the oField parameter. Valid values for order are: simple - breaks text up into same-size fragments with no concerns over spotting sentence boundaries. span - breaks text up into same-size fragments but does not split up Spans. */ fragmenter(f: string, oField: string): Highlight; /* Sets the size of each highlight fragment in characters. You can apply the option to a specific field by passing the field name in to the oField parameter. Default: 100 */ fragmentSize(size: number, oField: string): Highlight; /* Enables highlights in documents matched by a filter. You can apply the option to a specific field by passing the field name in to the oField parameter. Defaults to false. */ highlightFilter(trueFalse: boolean, oField: string): Highlight; /* Sets the number of highlight fragments. You can apply the option to a specific field by passing the field name in to the oField parameter. Default: 5 */ numberOfFragments(cnt: number, oField: string): Highlight; /* Sets arbitrary options that can be passed to the highlighter implementation in use. */ options(opts: string, oField: string): Highlight; /* Sets the order of highlight fragments. You can apply the option to a specific field by passing the field name in to the oField parameter. Valid values for order are: score - the score calculated by Lucene's highlighting framework. */ order(o: string, oField: string): Highlight; /* Sets the post tags for highlighted fragments. You can apply the tags to a specific field by passing the field name in to the oField parameter. */ postTags(tags: string | string[], oField: string): Highlight; /* Sets the pre tags for highlighted fragments. You can apply the tags to a specific field by passing the field name in to the oField parameter. */ preTags(tags: string | string[], oField: string): Highlight; /* When enabled it will cause a field to be highlighted only if a query matched that field. false means that terms are highlighted on all requested fields regardless if the query matches specifically on them. You can apply the option to a specific field by passing the field name in to the oField parameter. Defaults to false. */ requireFieldMatch(trueFalse: boolean, oField: string): Highlight; /* Sets the schema to be used for the tags. Valid values are: styled - 10 pre tags with css class of hltN, where N is 1-10 */ tagsSchema(s: string): Highlight; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the highligher type. You can apply the option to a specific field by passing the field name in to the oField parameter. Valid values for order are: fast-vector-highlighter - the fast vector based highligher highlighter - the slower plain highligher */ type(t: string, oField: string): Highlight; } /* A multi-bucket values source based aggregation that can be applied on numeric values extracted from the documents. It dynamically builds fixed size (a.k.a. interval) buckets over the values. */ export class HistogramAggregation implements Aggregation { /* Aggregation that can be applied on numeric values extracted from the documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): HistogramAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): HistogramAggregation; /* Set's the range/bounds for the histogram aggregation. Useful when you want to include buckets that might be outside the bounds of indexed documents. */ extendedBounds(min: number, max: number): HistogramAggregation; /* Sets the field to gather terms from. */ field(field: string): HistogramAggregation; /* Sets the format expression for the terms. Use for number or date formatting */ format(f: string): HistogramAggregation; /* Sets the histogram interval. Buckets are generated based on this interval value. */ interval(i: number): HistogramAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): HistogramAggregation; /* The script language being used. */ lang(language: string): HistogramAggregation; /* Only return terms that match more than a configured number of hits. */ minDocCount(num: number): HistogramAggregation; /* Sets order for the aggregated values. */ order(order: string, direction: string): HistogramAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): HistogramAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): HistogramAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): HistogramAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The histogram facet works with numeric data by building a histogram across intervals of the field values. Each value is rounded into an interval (or placed in a bucket), and statistics are provided per interval/bucket (count and total). Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class HistogramFacet implements Facet { /* A facet which returns the N most frequent terms within a collection or set of collections. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): HistogramFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): HistogramFacet; /* Sets the field to be used to construct the this facet. */ field(fieldName: string): HistogramFacet; /* Sets the "from", "start", or lower bounds bucket. For example if you have a value of 1023, an interval of 100, and a from value of 1500, it will be placed into the 1500 bucket vs. the normal bucket of 1000. */ from(from: Number): HistogramFacet; /* Computes values across the entire index */ global(trueFalse: boolean): HistogramFacet; /* Sets the bucket interval used to calculate the distribution. */ interval(numericInterval: Number): HistogramFacet; /* Allows you to specify a different key field to be used to group intervals. */ keyField(fieldName: string): HistogramFacet; /* Allows you modify the key field using a script. The modified value is then used to generate the interval. */ keyScript(scriptCode: string): HistogramFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): HistogramFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): HistogramFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): HistogramFacet; /* Sets the type of ordering that will be performed on the date buckets. Valid values are: key - the default, sort by the bucket's key value count - sort by the number of items in the bucket total - sort by the sum/total of the items in the bucket */ order(o: string): HistogramFacet; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): HistogramFacet; /* Computes values across the the specified scope */ scope(scope: string): HistogramFacet; /* Sets the bucket interval used to calculate the distribution based on a time value such as "1d", "1w", etc. */ timeInterval(timeInterval: Number): HistogramFacet; /* Sets the "to", "end", or upper bounds bucket. For example if you have a value of 1023, an interval of 100, and a to value of 900, it will be placed into the 900 bucket vs. the normal bucket of 1000. */ to(to: Number): HistogramFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Allows you to specify a different value field to aggrerate over. */ valueField(fieldName: string): HistogramFacet; /* Allows you modify the value field using a script. The modified value is then used to compute the statistical data. */ valueScript(scriptCode: string): HistogramFacet; } /* Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field. */ export class IdsFilter implements Filter { /* Matches documents with the specified id(s). */ constructor(ids: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): IdsFilter; /* Sets the cache key. */ cacheKey(key: string): IdsFilter; /* Sets the filter name. */ name(name: string): IdsFilter; /* Returns the filter object. */ toJSON(): IdsFilter; /* Sets the type as a single type or an array of types. If type is a string, it is added to the list of existing types. If type is an array, it is set as the types and overwrites an existing types. This parameter is optional. */ type(type: string | string[]): IdsFilter; /* Sets the values array or adds a new value. if val is a string, it is added to the list of existing document ids. If val is an array it is set as the document values and replaces any existing values. */ values(val: string | string[]): IdsFilter; } /* Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field. */ export class IdsQuery implements Query { /* Matches documents with the specified id(s). */ constructor(ids: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): IdsQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the type as a single type or an array of types. If type is a string, it is added to the list of existing types. If type is an array, it is set as the types and overwrites an existing types. This parameter is optional. */ type(type: string | string[]): IdsQuery; /* Sets the values array or adds a new value. if val is a string, it is added to the list of existing document ids. If val is an array it is set as the document values and replaces any existing values. */ values(val: string | string[]): IdsQuery; } /* A shape which has already been indexed in another index and/or index type. This is particularly useful for when you have a pre-defined list of shapes which are useful to your application and you want to reference this using a logical name (for example ‘New Zealand’) rather than having to provide their coordinates each time. */ export class IndexedShape implements Geo { /* Defines a shape that already exists in an index/type. */ constructor(type: string, id: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the document id of the indexed shape. */ id(id: string): IndexedShape; /* Sets the index which the shape is indexed under. Defaults to "shapes". */ index(idx: string): IndexedShape; /* Sets the field name containing the indexed shape. Defaults to "shape". */ shapeFieldName(field: string): IndexedShape; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the type which the shape is indexed under. */ type(t: string): IndexedShape; } /* The indices filter can be used when executed across multiple indices, allowing to have a filter that executes only when executed on an index that matches a specific list of indices, and another filter that executes when it is executed on an index that does not match the listed indices. */ export class IndicesFilter implements Filter { /* A configurable filter that is dependent on the index name. */ constructor(fltr: Object, indices: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): IndicesFilter; /* Sets the cache key. */ cacheKey(key: string): IndicesFilter; /* Sets the filter to be used when executing on one of the indicies specified. */ filter(f: Object): IndicesFilter; /* Sets the indicies the filter should match. When passed a string, the index name is added to the current list of indices. When passed an array, it overwites all current indices. */ indices(i: string | string[]): IndicesFilter; /* Sets the filter name. */ name(name: string): IndicesFilter; /* Sets the filter to be used on an index that does not match an index name in the indices list. Can also be set to "none" to not match any documents or "all" to match all documents. */ noMatchFilter(f: Filter | string): IndicesFilter; /* Returns the filter object. */ toJSON(): IndicesFilter; } /* The indices query can be used when executed across multiple indices, allowing to have a query that executes only when executed on an index that matches a specific list of indices, and another query that executes when it is executed on an index that does not match the listed indices. */ export class IndicesQuery implements Query { /* A configurable query that is dependent on the index name. */ constructor(qry: Query, indices: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): IndicesQuery; /* Sets the indicies the query should match. When passed a string, the index name is added to the current list of indices. When passed an array, it overwites all current indices. */ indices(i: string | string[]): IndicesQuery; /* Sets the query to be used on an index that does not match an index name in the indices list. Can also be set to "none" to not match any documents or "all" to match all documents. */ noMatchQuery(q: Query | string): IndicesQuery; /* Sets the query to be executed against the indices specified. */ query(q: Query): IndicesQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A dedicated range aggregation for IPv4 typed fields. Note that this aggregration includes the from value and excludes the to value for each range. */ export class IPv4RangeAggregation implements Aggregation { /* A dedicated range aggregation for IPv4 typed fields. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): IPv4RangeAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): IPv4RangeAggregation; /* Sets the field to gather terms from. */ field(field: string): IPv4RangeAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): IPv4RangeAggregation; /* The script language being used. */ lang(language: string): IPv4RangeAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): IPv4RangeAggregation; /* Adds a range to the list of exsiting range expressions. */ range(from: string, to: string, key: string): IPv4RangeAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): IPv4RangeAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): IPv4RangeAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A limit filter limits the number of documents (per shard) to execute on. */ export class LimitFilter implements Filter { /* Limits the number of documents to execute on. */ constructor(limit: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): LimitFilter; /* Sets the cache key. */ cacheKey(key: string): LimitFilter; /* Sets the filter name. */ name(name: string): LimitFilter; /* Returns the filter object. */ toJSON(): LimitFilter; /* Sets the limit value. */ value(val: number): LimitFilter; } /* This filter can be used to match on all the documents in a given set of collections and/or types. */ export class MatchAllFilter implements Filter { /* A filter that matches on all documents */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): MatchAllFilter; /* Sets the cache key. */ cacheKey(key: string): MatchAllFilter; /* Sets the filter name. */ name(name: string): MatchAllFilter; /* Returns the filter object. */ toJSON(): MatchAllFilter; } /* This query can be used to match all the documents in a given set of collections and/or types. */ export class MatchAllQuery implements Query { /* A query that returns all documents. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): MatchAllQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A MatchQuery is a type of Query that accepts text/numerics/dates, analyzes it, generates a query based on the MatchQuery type. */ export class MatchQuery implements Query { /* A Query that appects text, analyzes it, generates internal query based on the MatchQuery type. */ constructor(field: string, qstr: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the analyzer name used to analyze the Query object. */ analyzer(analyzer: string): MatchQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: Number): MatchQuery; /* Sets the maximum threshold/frequency to be considered a low frequency term in a CommonTermsQuery. Set to a value between 0 and 1. */ cutoffFrequency(freq: Number): MatchQuery; /* Sets the fuzziness value for the Query. */ fuzziness(fuzz: number): MatchQuery; /* Sets fuzzy rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ fuzzyRewrite(m: string): MatchQuery; /* Set to false to use classic Levenshtein edit distance in the fuzzy query. */ fuzzyTranspositions(trueFalse: boolean): MatchQuery; /* Enables lenient parsing of the query string. */ lenient(trueFalse: boolean): MatchQuery; /* Sets the max expansions of a fuzzy MatchQuery. */ maxExpansions(e: number): MatchQuery; /* Sets a percent value controlling how many "should" clauses in the resulting Query should match. */ minimumShouldMatch(minMatch: number): MatchQuery; /* Sets default operator of the Query. Default: or. */ operator(op: string): MatchQuery; /* Sets the prefix length for a fuzzy prefix MatchQuery. */ prefixLength(l: number): MatchQuery; /* Sets the query string for the Query. */ query(qstr: string): MatchQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): MatchQuery; /* Sets the default slop for phrases. If zero, then exact phrase matches are required. Default: 0. */ slop(slop: number): MatchQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the type of the MatchQuery. Valid values are boolean, phrase, and phrase_prefix. */ type(type: string): MatchQuery; /* Sets what happens when no terms match. Valid values are "all" or "none". */ zeroTermsQuery(q: string): MatchQuery; } /* A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. */ export class MaxAggregation implements Aggregation { /* Aggregation that keeps track and returns the maximum value among the numeric values extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): MaxAggregation; /* The script language being used. */ lang(language: string): MaxAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): MaxAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): MaxAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): MaxAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class MetricsAggregationMixin implements Aggregation { /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): MetricsAggregationMixin; /* The script language being used. */ lang(language: string): MetricsAggregationMixin; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): MetricsAggregationMixin; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): MetricsAggregationMixin; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): MetricsAggregationMixin; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A single-value metrics aggregation that keeps track and returns the minimum value among numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. */ export class MinAggregation implements Aggregation { /* Aggregation that keeps track and returns the minimum value among numeric values extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): MinAggregation; /* The script language being used. */ lang(language: string): MinAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): MinAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): MinAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): MinAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A field data based single bucket aggregation, that creates a bucket of all documents in the current document set context that are missing a field value (effectively, missing a field or having the configured NULL value set). */ export class MissingAggregation implements Aggregation { /* Defines a bucket of all documents that are missing a field value. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): MissingAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): MissingAggregation; /* Sets the field to gather missing terms from. */ field(field: string): MissingAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* An missingFilter matches documents where the specified field contains no legitimate value. */ export class MissingFilter implements Filter { /* Filters documents where a specific field has no value present. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): MissingFilter; /* Sets the cache key. */ cacheKey(key: string): MissingFilter; /* Checks if the field doesn't exist. */ existence(trueFalse: boolean): MissingFilter; /* Sets the field to check for missing values. */ field(name: string): MissingFilter; /* Sets the filter name. */ name(name: string): MissingFilter; /* Checks if the field has null values. */ nullValue(trueFalse: boolean): MissingFilter; /* Returns the filter object. */ toJSON(): MissingFilter; } /* The more_like_this_field query is the same as the more_like_this query, except it runs against a single field. */ export class MoreLikeThisFieldQuery implements Query { /* Constructs a query where each documents returned are “like” provided text */ constructor(field: string, likeText: string); /* The type of ejs object. For internal use only. */ _type(): string; /* The analyzer that will be used to analyze the text. Defaults to the analyzer associated with the field. */ analyzer(analyzerName: string): MoreLikeThisFieldQuery; /* Sets the boost value of the Query. */ boost(boost: number): MoreLikeThisFieldQuery; /* Sets the boost factor to use when boosting terms. Defaults to 1. */ boostTerms(boost: number): MoreLikeThisFieldQuery; /* Should the Query fail when an unsupported field is specified. Defaults to true. */ failOnUnsupportedField(trueFalse: boolean): MoreLikeThisFieldQuery; /* The field to run the query against. */ field(f: string): MoreLikeThisFieldQuery; /* The text to find documents like */ likeText(s: string): MoreLikeThisFieldQuery; /* The maximum frequency in which words may still appear. Words that appear in more than this many docs will be ignored. Defaults to unbounded. */ maxDocFreq(max: number): MoreLikeThisFieldQuery; /* The maximum number of query terms that will be included in any generated query. Defaults to 25. */ maxQueryTerms(max: number): MoreLikeThisFieldQuery; /* The maximum word length above which words will be ignored. Defaults to unbounded (0). */ maxWordLen(len: number): MoreLikeThisFieldQuery; /* The frequency at which words will be ignored which do not occur in at least this many docs. Defaults to 5. */ minDocFreq(min: number): MoreLikeThisFieldQuery; /* The frequency below which terms will be ignored in the source doc. The default frequency is 2. */ minTermFreq(freq: number): MoreLikeThisFieldQuery; /* The minimum word length below which words will be ignored. Defaults to 0. */ minWordLen(len: number): MoreLikeThisFieldQuery; /* The percentage of terms to match on (float value). Defaults to 0.3 (30 percent). */ percentTermsToMatch(percent: number): MoreLikeThisFieldQuery; /* An array of stop words. Any word in this set is considered “uninteresting” and ignored. Even if your Analyzer allows stopwords, you might want to tell the MoreLikeThis code to ignore them, as for the purposes of document similarity it seems reasonable to assume that “a stop word is never interesting”. */ stopWords(stopWords: any[]): MoreLikeThisFieldQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* More like this query find documents that are “like” provided text by running it against one or more fields. */ export class MoreLikeThisQuery implements Query { /* Constructs a query where each documents returned are “like” provided text */ constructor(fields: string | string[], likeText: string); /* The type of ejs object. For internal use only. */ _type(): string; /* The analyzer that will be used to analyze the text. Defaults to the analyzer associated with the field. */ analyzer(analyzerName: string): MoreLikeThisQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: number): MoreLikeThisQuery; /* Sets the boost factor to use when boosting terms. Defaults to 1. */ boostTerms(boost: number): MoreLikeThisQuery; /* Should the Query fail when an unsupported field is specified. Defaults to true. */ failOnUnsupportedField(trueFalse: boolean): MoreLikeThisQuery; /* The fields to run the query against. If you call with a single field, it is added to the existing list of fields. If called with an array of field names, it replaces any existing values with the new array. */ fields(f: string | string[]): MoreLikeThisQuery; /* The text to find documents like */ likeText(s: string): MoreLikeThisQuery; /* The maximum frequency in which words may still appear. Words that appear in more than this many docs will be ignored. Defaults to unbounded. */ maxDocFreq(max: number): MoreLikeThisQuery; /* The maximum number of query terms that will be included in any generated query. Defaults to 25. */ maxQueryTerms(max: number): MoreLikeThisQuery; /* The maximum word length above which words will be ignored. Defaults to unbounded (0). */ maxWordLen(len: number): MoreLikeThisQuery; /* The frequency at which words will be ignored which do not occur in at least this many docs. Defaults to 5. */ minDocFreq(min: number): MoreLikeThisQuery; /* The frequency below which terms will be ignored in the source doc. The default frequency is 2. */ minTermFreq(freq: number): MoreLikeThisQuery; /* The minimum word length below which words will be ignored. Defaults to 0. */ minWordLen(len: number): MoreLikeThisQuery; /* The percentage of terms to match on (float value). Defaults to 0.3 (30 percent). */ percentTermsToMatch(percent: number): MoreLikeThisQuery; /* An array of stop words. Any word in this set is considered “uninteresting” and ignored. Even if your Analyzer allows stopwords, you might want to tell the MoreLikeThis code to ignore them, as for the purposes of document similarity it seems reasonable to assume that “a stop word is never interesting”. */ stopWords(stopWords: any[]): MoreLikeThisQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A MultiMatchQuery query builds further on top of the MatchQuery by allowing multiple fields to be specified. The idea here is to allow to more easily build a concise match type query over multiple fields instead of using a relatively more expressive query by using multiple match queries within a bool query. */ export class MultiMatchQuery implements Query { /* A Query that allow to more easily build a MatchQuery over multiple fields */ constructor(fields: string | string[], qstr: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the analyzer name used to analyze the Query object. */ analyzer(analyzer: string): MultiMatchQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: number): MultiMatchQuery; /* Sets the maximum threshold/frequency to be considered a low frequency term in a CommonTermsQuery. Set to a value between 0 and 1. */ cutoffFrequency(freq: Number): MultiMatchQuery; /* Sets the fields to search across. If passed a single value it is added to the existing list of fields. If passed an array of values, they overwite all existing values. */ fields(f: string | string[]): MultiMatchQuery; /* Sets the fuzziness value for the Query. */ fuzziness(fuzz: number): MultiMatchQuery; /* Sets fuzzy rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ fuzzyRewrite(m: string): MultiMatchQuery; /* Enables lenient parsing of the query string. */ lenient(trueFalse: boolean): MultiMatchQuery; /* Sets the max expansions of a fuzzy Query. */ maxExpansions(e: number): MultiMatchQuery; /* Sets a percent value controlling how many "should" clauses in the resulting Query should match. */ minimumShouldMatch(minMatch: number): MultiMatchQuery; /* Sets default operator of the Query. Default: or. */ operator(op: string): MultiMatchQuery; /* Sets the prefix length for a fuzzy prefix Query. */ prefixLength(l: number): MultiMatchQuery; /* Sets the query string for the Query. */ query(qstr: string): MultiMatchQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): MultiMatchQuery; /* Sets the default slop for phrases. If zero, then exact phrase matches are required. Default: 0. */ slop(slop: number): MultiMatchQuery; /* The tie breaker value. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields. Default: 0.0. */ tieBreaker(tieBreaker: number): MultiMatchQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the type of the MultiMatchQuery. Valid values are boolean, phrase, and phrase_prefix or phrasePrefix. */ type(type: string): MultiMatchQuery; /* Sets whether or not queries against multiple fields should be combined using Lucene's DisjunctionMaxQuery */ useDisMax(trueFalse: string): MultiMatchQuery; /* Sets what happens when no terms match. Valid values are "all" or "none". */ zeroTermsQuery(q: string): MultiMatchQuery; } /* A special single bucket aggregation that enables aggregating nested documents. */ export class NestedAggregation implements Aggregation { /* A special single bucket aggregation that enables aggregating nested documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): NestedAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): NestedAggregation; /* Sets the nested path. */ path(path: string): NestedAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Nested filters allow you to search against content within objects that are embedded inside of other objects. It is similar to XPath expressions in XML both conceptually and syntactically. The filter is executed against the nested objects / docs as if they were indexed as separate docs and resulting in the root parent doc (or parent nested mapping). */ export class NestedFilter implements Filter { /* Constructs a filter that is capable of executing a filter against objects nested within a document. */ constructor(path: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value of the nested Query. */ boost(boost: number): NestedFilter; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): NestedFilter; /* Sets the cache key. */ cacheKey(key: string): NestedFilter; /* Sets the nested filter to be executed. */ filter(oFilter: Object): NestedFilter; /* If the nested query should be "joined" with the parent document. Defaults to false. */ join(trueFalse: boolean): NestedFilter; /* Sets the filter name. */ name(name: string): NestedFilter; /* Sets the root context for the nested filter. */ path(p: string): NestedFilter; /* Sets the nested query to be executed. */ query(oQuery: Query): NestedFilter; /* Sets the scope of the filter. A scope allows to run facets on the same scope name that will work against the nested documents. */ scope(s: string): NestedFilter; /* Returns the filter object. */ toJSON(): NestedFilter; } /* Nested queries allow you to search against content within objects that are embedded inside of other objects. It is similar to XPath expressions in XML both conceptually and syntactically. The query is executed against the nested objects / docs as if they were indexed as separate docs and resulting in the rootparent doc (or parent nested mapping). */ export class NestedQuery implements Query { /* Constructs a query that is capable of executing a search against objects nested within a document. */ constructor(path: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): NestedQuery; /* Sets the nested filter to be executed. */ filter(oFilter: Object): NestedQuery; /* Sets the root context for the nested query. */ path(path: string): NestedQuery; /* Sets the nested query to be executed. */ query(oQuery: Object): NestedQuery; /* Sets the scope of the query. A scope allows to run facets on the same scope name that will work against the nested documents. */ scope(s: string): NestedQuery; /* Sets how the inner (nested) matches affect scoring on the parent document. */ scoreMode(mode: string): NestedQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A container Filter that excludes the documents matched by the contained filter. */ export class NotFilter implements Filter { /* Container filter that excludes the matched documents of the contained filter. */ constructor(oFilter: Object); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): NotFilter; /* Sets the cache key. */ cacheKey(key: string): NotFilter; /* Sets the filter */ filter(fltr: Object): NotFilter; /* Sets the filter name. */ name(name: string): NotFilter; /* Returns the filter object. */ toJSON(): NotFilter; } /* Filters documents with fields that have values within a certain numeric range. Similar to range filter, except that it works only with numeric values, and the filter execution works differently. The numeric range filter works by loading all the relevant field values into memory, and checking for the relevant docs if they satisfy the range requirements. This requires more memory since the numeric range data are loaded to memory, but can provide a significant increase in performance. Note, if the relevant field values have already been loaded to memory, for example because it was used in facets or was sorted on, then this filter should be used. */ export class NumericRangeFilter implements Filter { /* A Filter that only accepts numeric values within a specified range. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): NumericRangeFilter; /* Sets the cache key. */ cacheKey(key: string): NumericRangeFilter; /* Returns the field name used to create this object. */ field(field: string): NumericRangeFilter; /* Sets the endpoint for the current range. */ from(startPoint: Number): NumericRangeFilter; /* Greater than value. Same as setting from to the value, and include_lower to false, */ gt(val: any): NumericRangeFilter; /* Greater than or equal to value. Same as setting from to the value, and include_lower to true. */ gte(val: any): NumericRangeFilter; /* Should the first from (if set) be inclusive or not. Defaults to true */ includeLower(trueFalse: boolean): NumericRangeFilter; /* Should the last to (if set) be inclusive or not. Defaults to true. */ includeUpper(trueFalse: boolean): NumericRangeFilter; /* Less than value. Same as setting to to the value, and include_upper to false. */ lt(val: any): NumericRangeFilter; /* Less than or equal to value. Same as setting to to the value, and include_upper to true. */ lte(val: any): NumericRangeFilter; /* Sets the filter name. */ name(name: string): NumericRangeFilter; /* Sets the endpoint for the current range. */ to(endPoint: Number): NumericRangeFilter; /* Returns the filter object. */ toJSON(): NumericRangeFilter; } /* A container filter that allows Boolean OR composition of filters. */ export class OrFilter implements Filter { /* A container Filter that allows Boolean OR composition of filters. */ constructor(filters: Filter | Filter[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): OrFilter; /* Sets the cache key. */ cacheKey(key: string): OrFilter; /* Updates the filters. If passed a single Filter it is added to the existing filters. If passed an array of Filters, they replace all existing Filters. */ filters(fltr: Filter | Filter[]): OrFilter; /* Sets the filter name. */ name(name: string): OrFilter; /* Returns the filter object. */ toJSON(): OrFilter; } /* A multi-value metrics aggregation that calculates one or more percentiles over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. */ export class PercentilesAggregation implements Aggregation { /* Aggregation that calculates one or more percentiles over numeric values extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Compression controls memory usage and approximation error. The compression value limits the maximum number of nodes to 100 * compression. By increasing the compression value, you can increase the accuracy of your percentiles at the cost of more memory. Larger compression values also make the algorithm slower since the underlying tree data structure grows in size, resulting in more expensive operations. The default compression value is 100. */ compression(c: number): PercentilesAggregation; /* Sets the field to operate on. */ field(field: string): PercentilesAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): PercentilesAggregation; /* The script language being used. */ lang(language: string): PercentilesAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): PercentilesAggregation; /* Add a single percentile to the current list of percentiles. */ percent(percentile: number): PercentilesAggregation; /* Sets the percentile bucket array. Overwrites all existing values. */ percents(percents: number[]): PercentilesAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): PercentilesAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): PercentilesAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* PhraseSuggester extends the PhraseSuggester and suggests entire corrected phrases instead of individual tokens. The individual phrase suggestions are weighted based on ngram-langugage models. In practice it will be able to make better decision about which tokens to pick based on co-occurence and frequencies. */ export class PhraseSuggester implements Suggest { /* A suggester that suggests entire corrected phrases. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets analyzer used to analyze the suggest text. */ analyzer(analyzer: string): PhraseSuggester; /* Sets the confidence level defines a factor applied to the input phrases score which is used as a threshold for other suggest candidates. Only candidates that score higher than the threshold will be included in the result. */ confidence(c: number): PhraseSuggester; /* Adds a direct generator. If passed a single Generator it is added to the list of existing generators. If passed an array of Generators, they replace all existing generators. */ directGenerator(oGenerator: Generator | Generator[]): PhraseSuggester; /* Sets the field used to generate suggestions from. */ field(field: string): PhraseSuggester; /* Forces the use of unigrams. */ forceUnigrams(trueFalse: boolean): PhraseSuggester; /* Sets the max size of the n-grams (shingles) in the field. If the field doesn't contain n-grams (shingles) this should be omitted or set to 1. */ gramSize(s: number): PhraseSuggester; /* Enables highlighting of suggestions */ highlight(preTag: string, postTag: string): PhraseSuggester; /* A smoothing model that uses an additive smoothing model where a constant (typically 1.0 or smaller) is added to all counts to balance weights, The default alpha is 0.5. */ laplaceSmoothing(alpha: number): PhraseSuggester; /* A smoothing model that takes the weighted mean of the unigrams, bigrams and trigrams based on user supplied weights (lambdas). The sum of tl, bl, and ul must equal 1. */ linearSmoothing(tl: number, bl: number, ul: number): PhraseSuggester; /* Sets the maximum percentage of the terms that at most considered to be misspellings in order to form a correction. */ maxErrors(c: number): PhraseSuggester; /* Sets the likelihood of a term being a misspelled even if the term exists in the dictionary. The default it 0.95 corresponding to 5% or the real words are misspelled. */ realWordErrorLikelihood(l: number): PhraseSuggester; /* Sets the separator that is used to separate terms in the bigram field. If not set the whitespce character is used as a separator. */ separator(sep: string): PhraseSuggester; /* Sets the maximum number of suggestions to be retrieved from each individual shard. */ shardSize(s: number): PhraseSuggester; /* Sets the number of suggestions returned for each token. */ size(s: number): PhraseSuggester; /* A simple backoff model that backs off to lower order n-gram models if the higher order count is 0 and discounts the lower order n-gram model by a constant factor. The default discount is 0.4. */ stupidBackoffSmoothing(discount: number): PhraseSuggester; /* Sets the text to get suggestions for. If not set, the global suggestion text will be used. */ text(txt: string): PhraseSuggester; /* Retrieves the internal suggest object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the token limit. */ tokenLimit(l: number): PhraseSuggester; } /* Filters documents that have fields containing terms with a specified prefix (not analyzed). Similar to phrase query, except that it acts as a filter. Can be placed within queries that accept a filter. */ export class PrefixFilter implements Filter { /* Filters documents that have fields containing terms with a specified prefix. */ constructor(fieldName: string, prefix: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): PrefixFilter; /* Sets the cache key. */ cacheKey(key: string): PrefixFilter; /* Returns the field name used to create this object. */ field(field: string): PrefixFilter; /* Sets the filter name. */ name(name: string): PrefixFilter; /* Sets the prefix to search for. */ prefix(value: string): PrefixFilter; /* Returns the filter object. */ toJSON(): PrefixFilter; } /* Matches documents that have fields containing terms with a specified prefix (not analyzed). The prefix query maps to Lucene PrefixQuery. */ export class PrefixQuery implements Query { /* Matches documents containing the specified un-analyzed prefix. */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value of the Query. */ boost(boost: number): PrefixQuery; /* The field to run the query against. */ field(f: string): PrefixQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): PrefixQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* The prefix value. */ value(p: string): PrefixQuery; } /* The QueryFacet facet allows you to specify any valid Query and have the number of matching hits returned as the value. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class QueryFacet implements Facet { /* A facet that return a count of the hits matching the given query. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): QueryFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): QueryFacet; /* Computes values across the entire index */ global(trueFalse: boolean): QueryFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): QueryFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): QueryFacet; /* Sets the query to be used for this facet. */ query(oQuery: Object): QueryFacet; /* Computes values across the the specified scope */ scope(scope: string): QueryFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Wraps any query to be used as a filter. Can be placed within queries that accept a filter. The result of the filter is not cached by default. Set the cache parameter to true to cache the result of the filter. This is handy when the same query is used on several (many) other queries. Note, the process of caching the first execution is higher when not caching (since it needs to satisfy different queries). */ export class QueryFilter implements Filter { /* Filters documents matching the wrapped query. */ constructor(qry: Object); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): QueryFilter; /* Sets the cache key. */ cacheKey(key: string): QueryFilter; /* Sets the filter name. */ name(name: string): QueryFilter; /* Sets the query */ query(q: Object): QueryFilter; /* Returns the filter object. */ toJSON(): QueryFilter; } export class QueryMixin { /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): QueryMixin; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A query that is parsed using Lucene's default query parser. Although Lucene provides the ability to create your own queries through its API, it also provides a rich query language through the Query Parser, a lexer which interprets a string into a Lucene Query. See the Lucene Query Parser Syntax for more information. */ export class QueryStringQuery implements Query { /* A query that is parsed using Lucene's default query parser. */ constructor(qstr: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets whether or not wildcard characters (* and ?) are allowed as the first character of the Query. Default: true. */ allowLeadingWildcard(trueFalse: boolean): QueryStringQuery; /* Sets the analyzer name used to analyze the Query object. */ analyzer(analyzer: string): QueryStringQuery; /* Sets whether or not we should attempt to analyzed wilcard terms in the Query. By default, wildcard terms are not analyzed. Analysis of wildcard characters is not perfect. Default: false. */ analyzeWildcard(trueFalse: boolean): QueryStringQuery; /* Sets whether or not we should auto generate phrase queries *if* the analyzer returns more than one term. Default: false. */ autoGeneratePhraseQueries(trueFalse: boolean): QueryStringQuery; /* Sets the boost value for documents matching the Query. */ boost(boost: number): QueryStringQuery; /* Sets the default field/property this query should execute against. */ defaultField(fieldName: string): QueryStringQuery; /* Set the default Boolean operator. This operator is used to join individual query terms when no operator is explicity used in the query string (i.e., this AND that). Defaults to OR. */ defaultOperator(op: string): QueryStringQuery; /* Sets whether or not position increments will be used in the Query. Default: true. */ enablePositionIncrements(trueFalse: boolean): QueryStringQuery; /* If they query string should be escaped or not. */ escape(trueFalse: boolean): QueryStringQuery; /* A set of fields/properties this query should execute against. Pass a single value to add to the existing list of fields and pass an array to overwrite all existing fields. For each field, you can apply a field specific boost by appending a ^boost to the field name. For example, title^10, to give the title field a boost of 10. */ fields(fieldNames: any[]): QueryStringQuery; /* Sets the max number of term expansions for fuzzy queries. */ fuzzyMaxExpansions(max: number): QueryStringQuery; /* Set the minimum similarity for fuzzy queries. Default: 0.5. */ fuzzyMinSim(minSim: number): QueryStringQuery; /* Sets the prefix length for fuzzy queries. Default: 0. */ fuzzyPrefixLength(fuzzLen: number): QueryStringQuery; /* Sets fuzzy rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ fuzzyRewrite(m: string): QueryStringQuery; /* Enables lenient parsing of the query string. */ lenient(trueFalse: boolean): QueryStringQuery; /* Sets whether or not terms from wildcard, prefix, fuzzy, and range queries should automatically be lowercased in the Query since they are not analyzed. Default: true. */ lowercaseExpandedTerms(trueFalse: boolean): QueryStringQuery; /* Sets a percent value controlling how many "should" clauses in the resulting Query should match. */ minimumShouldMatch(minMatch: number): QueryStringQuery; /* Sets the default slop for phrases. If zero, then exact phrase matches are required. Default: 0. */ phraseSlop(slop: number): QueryStringQuery; /* Sets the query string on this Query object. */ query(qstr: string): QueryStringQuery; /* Sets the quote analyzer name used to analyze the query when in quoted text. */ quoteAnalyzer(analyzer: string): QueryStringQuery; /* Sets the suffix to automatically add to the field name when performing a quoted search. */ quoteFieldSuffix(s: string): QueryStringQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): QueryStringQuery; /* Sets the tie breaker value for a Query using DisMax. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields. Default: 0.0. */ tieBreaker(tieBreaker: number): QueryStringQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets whether or not queries against multiple fields should be combined using Lucene's DisjunctionMaxQuery */ useDisMax(trueFalse: string): QueryStringQuery; } /* The random_score generates scores via a pseudo random number algorithm that is initialized with a seed. */ export class RandomScoreFunction implements ScoreFunction { /* Randomly score documents. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Adds a filter whose matching documents will have the score function applied. */ filter(oFilter: Filter): RandomScoreFunction; /* Sets random seed value. */ seed(s: number): RandomScoreFunction; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A multi-bucket value source based aggregation that enables the user to define a set of ranges - each representing a bucket. During the aggregation process, the values extracted from each document will be checked against each bucket range and "bucket" the relevant/matching document. Note that this aggregration includes the from value and excludes the to value for each range. */ export class RangeAggregation implements Aggregation { /* Aggregation that enables the user to define a set of ranges that each represent a bucket. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): RangeAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): RangeAggregation; /* Sets the field to gather terms from. */ field(field: string): RangeAggregation; /* Enable the response to be returned as a keyed object where the key is the bucket interval. */ keyed(trueFalse: boolean): RangeAggregation; /* The script language being used. */ lang(language: string): RangeAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): RangeAggregation; /* Adds a range to the list of exsiting range expressions. */ range(from: number, to?: number, key?: string): RangeAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): RangeAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): RangeAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A RangeFacet allows you to specify a set of ranges and get both the number of docs (count) that fall within each range, and aggregated data based on the field, or another specified field. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class RangeFacet implements Facet { /* A facet which provides information over a range of numeric intervals. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Adds a new bounded range. */ addRange(from: Number, to: Number): RangeFacet; /* Adds a new unbounded lower limit. */ addUnboundedFrom(from: Number): RangeFacet; /* Adds a new unbounded upper limit. */ addUnboundedTo(to: Number): RangeFacet; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): RangeFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): RangeFacet; /* Sets the document field to be used for the facet. */ field(fieldName: string): RangeFacet; /* Computes values across the entire index */ global(trueFalse: boolean): RangeFacet; /* Allows you to specify an alternate key field to be used to compute the interval. */ keyField(fieldName: string): RangeFacet; /* Allows you modify the key field using a script. The modified value is then used to generate the interval. */ keyScript(scriptCode: string): RangeFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): RangeFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): RangeFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): RangeFacet; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): RangeFacet; /* Computes values across the the specified scope */ scope(scope: string): RangeFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Allows you to specify an alternate value field to be used to compute statistical information. */ valueField(fieldName: string): RangeFacet; /* Allows you modify the value field using a script. The modified value is then used to compute the statistical data. */ valueScript(scriptCode: string): RangeFacet; } /* Matches documents with fields that have terms within a certain range. */ export class RangeFilter implements Filter { /* Filters documents with fields that have terms within a certain range. */ constructor(field: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): RangeFilter; /* Sets the cache key. */ cacheKey(key: string): RangeFilter; /* The field to run the filter against. */ field(f: string): RangeFilter; /* The lower bound. Defaults to start from the first. */ from(f: any): RangeFilter; /* Greater than value. Same as setting from to the value, and include_lower to false, */ gt(val: any): RangeFilter; /* Greater than or equal to value. Same as setting from to the value, and include_lower to true. */ gte(val: any): RangeFilter; /* Should the first from (if set) be inclusive or not. Defaults to true */ includeLower(trueFalse: boolean): RangeFilter; /* Should the last to (if set) be inclusive or not. Defaults to true. */ includeUpper(trueFalse: boolean): RangeFilter; /* Less than value. Same as setting to to the value, and include_upper to false. */ lt(val: any): RangeFilter; /* Less than or equal to value. Same as setting to to the value, and include_upper to true. */ lte(val: any): RangeFilter; /* Sets the filter name. */ name(name: string): RangeFilter; /* The upper bound. Defaults to unbounded. */ to(t: any): RangeFilter; /* Returns the filter object. */ toJSON(): RangeFilter; } /* Matches documents with fields that have terms within a certain range. The type of the Lucene query depends on the field type, for string fields, the TermRangeQuery, while for number/date fields, the query is a NumericRangeQuery. */ export class RangeQuery implements Query { /* Matches documents with fields that have terms within a certain range. */ constructor(field: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value of the Query. */ boost(boost: number): RangeQuery; /* The field to run the query against. */ field(f: string): RangeQuery; /* The lower bound. Defaults to start from the first. */ from(f: any): RangeQuery; /* Greater than value. Same as setting from to the value, and include_lower to false, */ gt(val: any): RangeQuery; /* Greater than or equal to value. Same as setting from to the value, and include_lower to true. */ gte(val: any): RangeQuery; /* Should the first from (if set) be inclusive or not. Defaults to true */ includeLower(trueFalse: boolean): RangeQuery; /* Should the last to (if set) be inclusive or not. Defaults to true. */ includeUpper(trueFalse: boolean): RangeQuery; /* Less than value. Same as setting to to the value, and include_upper to false. */ lt(val: any): RangeQuery; /* Less than or equal to value. Same as setting to to the value, and include_upper to true. */ lte(val: any): RangeQuery; /* The upper bound. Defaults to unbounded. */ to(t: any): RangeQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Filters documents that have a field value matching a regular expression. Based on Lucene 4.0 RegexpFilter which uses automaton to efficiently iterate over index terms. */ export class RegexpFilter implements Filter { /* Matches documents that have fields matching a regular expression. */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): RegexpFilter; /* Sets the cache key. */ cacheKey(key: string): RegexpFilter; /* The field to run the filter against. */ field(f: string): RegexpFilter; /* The regex flags to use. Valid flags are: INTERSECTION - Support for intersection notation COMPLEMENT - Support for complement notation EMPTY - Support for the empty language symbol: # ANYSTRING - Support for the any string symbol: @ INTERVAL - Support for numerical interval notation: NONE - Disable support for all syntax options ALL - Enables support for all syntax options Use multiple flags by separating with a "|" character. Example: INTERSECTION|COMPLEMENT|EMPTY */ flags(f: string): RegexpFilter; /* The regex flags to use as a numeric value. Advanced use only, it is probably better to stick with the flags option. */ flagsValue(v: string): RegexpFilter; /* Sets the filter name. */ name(name: string): RegexpFilter; /* Returns the filter object. */ toJSON(): RegexpFilter; /* The regexp value. */ value(p: string): RegexpFilter; } /* Matches documents that have fields matching a regular expression. Based on Lucene 4.0 RegexpQuery which uses automaton to efficiently iterate over index terms. */ export class RegexpQuery implements Query { /* Matches documents that have fields matching a regular expression. */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value of the Query. */ boost(boost: number): RegexpQuery; /* The field to run the query against. */ field(f: string): RegexpQuery; /* The regex flags to use. Valid flags are: INTERSECTION - Support for intersection notation COMPLEMENT - Support for complement notation EMPTY - Support for the empty language symbol: # ANYSTRING - Support for the any string symbol: @ INTERVAL - Support for numerical interval notation: NONE - Disable support for all syntax options ALL - Enables support for all syntax options Use multiple flags by separating with a "|" character. Example: INTERSECTION|COMPLEMENT|EMPTY */ flags(f: string): RegexpQuery; /* The regex flags to use as a numeric value. Advanced use only, it is probably better to stick with the flags option. */ flagsValue(v: string): RegexpQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): RegexpQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* The regexp value. */ value(p: string): RegexpQuery; } /* The Request object provides methods generating an elasticsearch request body. */ export class Request { /* Provides methods for generating request bodies. */ constructor(conf: Object); /* The type of ejs object. For internal use only. */ _type(): string; /* Add an aggregation. This method can be called multiple times in order to set multiple nested aggregations that will be executed at the same time as the search request. Alias for the aggregation method. */ agg(agg: Aggregation): Request; /* Add an aggregation. This method can be called multiple times in order to set multiple nested aggregations that will be executed at the same time as the search request. */ aggregation(agg: Aggregation): Request; /* Enable/Disable explanation of score for each search result. */ explain(trueFalse: boolean): Request; /* Allows you to set the specified facet on this request object. Multiple facets can be set, all of which will be returned when the search is executed. */ facet(facet: Facet): Request; /* By default, searches return full documents, meaning every property or field. This method allows you to specify which fields you want returned. Pass a single field name and it is appended to the current list of fields. Pass an array of fields and it replaces all existing fields. */ fields(s: string | string[]): Request; /* Allows you to set a specified filter on this request object. */ filter(filter: Filter): Request; /* A search result set could be very large (think Google). Setting the from parameter allows you to page through the result set by making multiple request. This parameters specifies the starting result/document number point. Combine with size() to achieve paging. */ from(f: number): Request; /* Performs highlighting based on the Highlight settings. */ highlight(h: Highlight): Request; /* Boosts hits in the specified index by the given boost value. */ indexBoost(index: string, boost: number): Request; /* Filters out search results will scores less than the specified minimum score. */ minScore(min: number): Request; /* Allows you to set the specified query on this search object. This is the query that will be used when the search is executed. */ query(someQuery: Query): Request; /* Once a query executes, you can use rescore to run a secondary, more expensive query to re-order the results. */ rescore(r: Rescore): Request; /* Computes a document property dynamically based on the supplied ScriptField. */ scriptField(oScriptField: ScriptField): Request; /* Sets the number of results/documents to be returned. This is set on a per page basis. */ size(s: number): Request; /* Sets the sorting for the query. This accepts many input formats. sort() - The current sorting values are returned. sort(fieldName) - Adds the field to the current list of sorting values. sort(fieldName, order) - Adds the field to the current list of sorting with the specified order. Order must be asc or desc. sort(ejs.Sort) - Adds the Sort value to the current list of sorting values. sort(array) - Replaces all current sorting values with values from the array. The array must contain only strings and Sort objects. Multi-level sorting is supported so the order in which sort fields are added to the query requests is relevant. It is recommended to use Sort objects when possible. */ sort(fieldName?: string | any[] | Sort, order?: string): Request; /* Allows to control how the _source field is returned with every hit. By default operations return the contents of the _source field unless you have used the fields parameter or if the _source field is disabled. Set the includes parameter to false to completely disable returning the source field. */ source(includes: string | boolean | string[], excludes: string | string[]): Request; /* Allows you to set the specified suggester on this request object. Multiple suggesters can be set, all of which will be returned when the search is executed. Global suggestion text can be set by passing in a string vs. a Suggest object. */ suggest(s: string | Suggest): Request; /* A timeout, bounding the request to be executed within the specified time value and bail when expired. Defaults to no timeout. This option is valid during the following operations: search and delete by query */ timeout(t: number): Request; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Enables score computation and tracking during sorting. Be default, when sorting scores are not computed. */ trackScores(trueFalse: boolean): Request; /* Enable/Disable returning version number for each search result. */ version(trueFalse: boolean): Request; } /* A method that allows to rescore queries with a typically more expensive. */ export class Rescore { /* Defines an operation that rescores a query with another query. */ //constructor(windowSize: Number, windowSize: Query); constructor(windowSize: Number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the weight assigned to the original query of the rescoring. */ queryWeight(weight: Number): Rescore; /* Sets the query used by the rescoring. */ rescoreQuery(someQuery: Query): Rescore; /* Sets the weight assigned to the query used to rescore the original query. */ rescoreQueryWeight(weight: Number): Rescore; /* Sets the scoring mode. Valid values are: total - default mode, the scores combined multiply - the scores multiplied min - the lowest of the scores max - the highest score avg - the average of the scores */ scoreMode(s: string): Rescore; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the window_size parameter of the rescoring. */ windowSize(size: Number): Rescore; } export class ScoreFunctionMixin implements ScoreFunction { /* The type of ejs object. For internal use only. */ _type(): string; /* Adds a filter whose matching documents will have the score function applied. */ filter(oFilter: Filter): ScoreFunctionMixin; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* ScriptField's allow you create dynamic fields on stored documents at query time. For example, you might have a set of document thats containsthe fields price and quantity. At query time, you could define a computed property that dynamically creates a new field called totalin each document based on the calculation price * quantity. */ export class ScriptField { /* Computes dynamic document properties based on information from other fields. */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* If execeptions thrown from the script should be ignored or not. Default: false */ ignoreFailure(trueFalse: boolean): ScriptField; /* The script language being used. Currently supported values are javascript and mvel. */ lang(language: string): ScriptField; /* Allows you to set script parameters to be used during the execution of the script. */ params(oParams: Object): ScriptField; /* Sets the script/code that will be used to perform the calculation. */ script(expression: string): ScriptField; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A filter allowing to define scripts as filters */ export class ScriptFilter implements Filter { /* A filter allowing to define scripts as filters. */ constructor(script: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): ScriptFilter; /* Sets the cache key. */ cacheKey(key: string): ScriptFilter; /* Sets the script language. */ lang(lang: string): ScriptFilter; /* Sets the filter name. */ name(name: string): ScriptFilter; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): ScriptFilter; /* Sets the script. */ script(s: string): ScriptFilter; /* Returns the filter object. */ toJSON(): ScriptFilter; } /* The script_score function allows you to wrap another query and customize the scoring of it optionally with a computation derived from other numeric field values in the doc using a script expression. */ export class ScriptScoreFunction implements ScoreFunction { /* Modify a documents score using a script. */ constructor(); /* The type of ejs object. For internal use only. */ _type(): string; /* Adds a filter whose matching documents will have the score function applied. */ filter(oFilter: Filter): ScriptScoreFunction; /* The script language being used. */ lang(language: string): ScriptScoreFunction; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): ScriptScoreFunction; /* Set the script that will modify the score. */ script(scriptCode: string): ScriptScoreFunction; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A Shape object that can be used in queries and filters that take a Shape. Shape uses the GeoJSON format. See http://www.geojson.org/ */ export class Shape implements Geo { /* Defines a shape */ constructor(type: string, coords: any[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the coordinates for the shape definition. Note, the coordinates are not validated in this api. Please see GeoJSON and ElasticSearch documentation for correct coordinate definitions. */ coordinates(c: any[]): Shape; /* Sets the radius for parsing a circle Shape. */ radius(r: string): Shape; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the shape type. Can be set to one of: point, linestring, polygon, multipoint, envelope, or multipolygon. */ type(t: string): Shape; } /* An aggregation that returns interesting or unusual occurrences of terms in a set. */ export class SignificantTermsAggregation implements Aggregation { /* An aggregation that returns interesting or unusual occurrences of terms in a set. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): SignificantTermsAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): SignificantTermsAggregation; /* Allows you to filter out unwanted facet entries using a regular expression. You can also optionally pass in a set of flags to apply to the regular expression. Valid flags are: CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, COMMENTS, and UNICODE_CHAR_CLASS. Separate multiple flags with a | character. */ exclude(exclude: string, flags: string): SignificantTermsAggregation; /* Sets the execution hint determines how the aggregation is computed. Supported values are: map and ordinals. */ executionHint(h: string): SignificantTermsAggregation; /* Sets the field to gather terms from. */ field(field: string): SignificantTermsAggregation; /* Sets the format expression for the terms. Use for number or date formatting. */ format(f: string): SignificantTermsAggregation; /* Allows you to allow only specific entries using a regular expression. You can also optionally pass in a set of flags to apply to the regular expression. Valid flags are: CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, COMMENTS, and UNICODE_CHAR_CLASS. Separate multiple flags with a | character. */ include(include: string, flags: string): SignificantTermsAggregation; /* Only return terms that match more than a configured number of hits. */ minDocCount(num: number): SignificantTermsAggregation; /* Determines how many terms the coordinating node will request from each shard. */ shardSize(shardSize: number): SignificantTermsAggregation; /* Sets the number of aggregation entries that will be returned. */ size(size: number): SignificantTermsAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A Sort object that can be used in on the Request object to specify various types of sorting. See http://www.elasticsearch.org/guide/reference/api/search/sort.html */ export class Sort { /* Defines a sort value */ constructor(fieldName: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the sort order to ascending (asc). Same as calling order('asc'). */ asc(): Sort; /* Sets the sort order to descending (desc). Same as calling order('desc'). */ desc(): Sort; /* How to compute the distance. Can either be arc (better precision) or plane (faster). Defaults to arc. Valid during sort types: geo distance */ distanceType(type: string): Sort; /* Set's the field to sort on */ field(f: string): Sort; /* Enables sorting based on a distance from a GeoPoint */ geoDistance(point: GeoPoint): Sort; /* Sets if the sort should ignore unmapped fields vs throwing an error. Valid during sort types: field */ ignoreUnmapped(trueFalse: boolean): Sort; /* Sets the script language. Valid during sort types: script */ lang(lang: string): Sort; /* Sets the value to use for missing fields. Valid values are: _last - to put documents with the field missing last _first - to put documents with the field missing first {String} - any string value to use as the sort value. Valid during sort types: field */ missing(m: string): Sort; /* Sets the sort mode. Valid values are: min - sort by lowest value max - sort by highest value sum - sort by the sum of all values avg - sort by the average of all values Valid during sort types: field, geo distance */ mode(m: string): Sort; /* Allows you to set a filter that nested objects must match in order to be considered during sorting. Valid during sort types: field, geo distance */ nestedFilter(oFilter: Object): Sort; /* Sets the path of the nested object. Valid during sort types: field, geo distance */ nestedPath(path: string): Sort; /* If the lat/long points should be normalized to lie within their respective normalized ranges. Normalized ranges are: lon = -180 (exclusive) to 180 (inclusive) range lat = -90 to 90 (both inclusive) range Valid during sort types: geo distance */ normalize(trueFalse: string): Sort; /* Sets the sort order. Valid values are: asc - for ascending order desc - for descending order Valid during sort types: field, geo distance, and script */ order(o: string): Sort; /* Sets parameters that will be applied to the script. Overwrites any existing params. Valid during sort types: script */ params(p: Object): Sort; /* Sets the order with a boolean value. true = descending sort order false = ascending sort order Valid during sort types: field, geo distance, and script */ reverse(trueFalse: boolean): Sort; /* Enables sorting based on a script. */ script(scriptCode: string): Sort; /* Retrieves the internal script object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the script sort type. Valid values are: string - script return value is sorted as a string number - script return value is sorted as a number Valid during sort types: script */ type(type: string): Sort; /* Sets the distance unit. Valid values are "mi" for miles or "km" for kilometers. Defaults to "km". Valid during sort types: geo distance */ unit(unit: string): Sort; } /* Matches spans near the beginning of a field. The spanFirstQuery allows you to search for Spans that start and end within the first n positions of the document. The span first query maps to Lucene SpanFirstQuery. */ export class SpanFirstQuery implements Query { /* Matches spans near the beginning of a field. */ constructor(spanQry: Query, end: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanFirstQuery; /* Sets the maximum end position permitted in a match. */ end(position: Number): SpanFirstQuery; /* Sets the span query to match on. */ match(spanQuery: Object): SpanFirstQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Wraps lucene MultiTermQueries as a SpanQuery so it can be used in the various Span* queries. Examples of valid MultiTermQueries are Fuzzy, NumericRange, Prefix, Regex, Range, and Wildcard. */ export class SpanMultiTermQuery implements Query { /* Use MultiTermQueries as a SpanQuery. */ constructor(qry: Query); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanMultiTermQuery; /* Sets the span query to match on. */ match(mtQuery: Object): SpanMultiTermQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A spanNearQuery will look to find a number of spanQuerys within a given distance from each other. */ export class SpanNearQuery implements Query { /* Matches spans which are near one another. */ constructor(clauses: Query | Query[], slop: number); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanNearQuery; /* Sets the clauses used. If passed a single SpanQuery, it is added to the existing list of clauses. If passed an array of SpanQueries, they replace any existing clauses. */ clauses(clauses: Query | Query[]): SpanNearQuery; /* Sets whether or not payloads are being used. A payload is an arbitrary byte array stored at a specific position (i.e. token/term). */ collectPayloads(trueFalse: boolean): SpanNearQuery; /* Sets whether or not matches are required to be in-order. */ inOrder(trueFalse: boolean): SpanNearQuery; /* Sets the maximum number of intervening unmatched positions. */ slop(distance: Number): SpanNearQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Removes matches which overlap with another span query. The span not query maps to Lucene SpanNotQuery. */ export class SpanNotQuery implements Query { /* Removes matches which overlap with another span query. */ constructor(includeQry: Query, excludeQry: Query); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanNotQuery; /* Sets the span query whose matches must not overlap those returned. */ exclude(spanQuery: Object): SpanNotQuery; /* Set the span query whose matches are filtered. */ include(spanQuery: Object): SpanNotQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* The spanOrQuery takes an array of SpanQuerys and will match if any of the underlying SpanQueries match. The span or query maps to Lucene SpanOrQuery. */ export class SpanOrQuery implements Query { /* Matches the union of its span clauses. */ constructor(clauses: Object); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanOrQuery; /* Sets the clauses used. If passed a single SpanQuery, it is added to the existing list of clauses. If passed an array of SpanQueries, they replace any existing clauses. */ clauses(clauses: Query | Query[]): SpanOrQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A spanTermQuery is the basic unit of Lucene's Span Query which allows for nested, positional restrictions when matching documents. The spanTermQuery simply matches spans containing a term. It's essentially a termQuery with positional information asscoaited. */ export class SpanTermQuery implements Query { /* Matches spans containing a term */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): SpanTermQuery; /* Sets the field to query against. */ field(f: string): SpanTermQuery; /* Sets the term. */ term(t: string): SpanTermQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A statistical facet allows you to compute statistical data over a numeric fields. Statistical data includes the count, total, sum of squares, mean (average), minimum, maximum, variance, and standard deviation. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class StatisticalFacet implements Facet { /* A facet which returns statistical information about a numeric field */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): StatisticalFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): StatisticalFacet; /* Sets the field to be used to construct the this facet. */ field(fieldName: string): StatisticalFacet; /* Aggregate statistical info across a set of fields. */ fields(aFieldName: any[]): StatisticalFacet; /* Computes values across the entire index */ global(trueFalse: boolean): StatisticalFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): StatisticalFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): StatisticalFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): StatisticalFacet; /* Allows you to set script parameters to be used during the execution of the script. */ params(oParams: Object): StatisticalFacet; /* Computes values across the the specified scope */ scope(scope: string): StatisticalFacet; /* Define a script to evaluate of which the result will be used to generate the statistical information. */ script(code: string): StatisticalFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. The stats that are returned consist of: min, max, sum, count and avg. */ export class StatsAggregation implements Aggregation { /* Aggregation that computes stats over numeric values extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): StatsAggregation; /* The script language being used. */ lang(language: string): StatsAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): StatsAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): StatsAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): StatsAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } export class SuggestContextMixin { /* Sets analyzer used to analyze the suggest text. */ analyzer(analyzer: string): SuggestContextMixin; /* Sets the field used to generate suggestions from. */ field(field: string): SuggestContextMixin; /* Sets the maximum number of suggestions to be retrieved from each individual shard. */ shardSize(s: number): SuggestContextMixin; /* Sets the number of suggestions returned for each token. */ size(s: number): SuggestContextMixin; } export class SuggesterMixin { /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the text to get suggestions for. If not set, the global suggestion text will be used. */ text(txt: string): SuggesterMixin; /* Retrieves the internal suggest object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A single-value metrics aggregation that sums up numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. */ export class SumAggregation implements Aggregation { /* Aggregation that sums up numeric values that are extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): SumAggregation; /* The script language being used. */ lang(language: string): SumAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): SumAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): SumAggregation; /* Set to true to assume script values are sorted. */ scriptValuesSorted(trueFalse: boolean): SumAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Constructs a filter for docs matching any of the terms added to this object. Unlike a RangeFilter this can be used for filtering on multiple terms that are not necessarily in a sequence. */ export class TermFilter implements Filter { /* Constructs a filter for docs matching the term added to this object. */ constructor(fieldName: string, term: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): TermFilter; /* Sets the cache key. */ cacheKey(key: string): TermFilter; /* Provides access to the filter fieldName used to construct the termFilter object. */ field(f: string): TermFilter; /* Sets the filter name. */ name(name: string): TermFilter; /* Provides access to the filter term used to construct the termFilter object. */ term(): TermFilter; /* Returns the filter object. */ toJSON(): TermFilter; } /* A TermQuery can be used to return documents containing a given keyword or term. For instance, you might want to retieve all the documents/objects that contain the term Javascript. Term filters often serve as the basis for more complex queries such as Boolean queries. */ export class TermQuery implements Query { /* A Query that matches documents containing a term. This may be combined with other terms with a BooleanQuery. */ constructor(field: string, term: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: Number): TermQuery; /* Sets the fields to query against. */ field(f: string): TermQuery; /* Sets the term. */ term(t: string): TermQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A multi-bucket value source based aggregation where buckets are dynamically built - one per unique value. */ export class TermsAggregation implements Aggregation { /* Defines an aggregation of unique values/terms. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. Alias for the aggregation method. */ agg(agg: Aggregation): TermsAggregation; /* Add a nested aggregation. This method can be called multiple times in order to set multiple nested aggregations what will be executed at the same time as the parent aggregation. */ aggregation(agg: Aggregation): TermsAggregation; /* Allows you to filter out unwanted facet entries using a regular expression. You can also optionally pass in a set of flags to apply to the regular expression. Valid flags are: CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, COMMENTS, and UNICODE_CHAR_CLASS. Separate multiple flags with a | character. */ exclude(exclude: string, flags: string): TermsAggregation; /* Sets the execution hint determines how the aggregation is computed. Supported values are: map and ordinals. */ executionHint(h: string): TermsAggregation; /* Sets the field to gather terms from. */ field(field: string): TermsAggregation; /* Sets the format expression for the terms. Use for number or date formatting */ format(f: string): TermsAggregation; /* Allows you to allow only specific entries using a regular expression. You can also optionally pass in a set of flags to apply to the regular expression. Valid flags are: CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, COMMENTS, and UNICODE_CHAR_CLASS. Separate multiple flags with a | character. */ include(include: string, flags: string): TermsAggregation; /* The script language being used. */ lang(language: string): TermsAggregation; /* Only return terms that match more than a configured number of hits. */ minDocCount(num: number): TermsAggregation; /* Sets order for the aggregated values. */ order(order: string, direction: string): TermsAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): TermsAggregation; /* Allows you generate or modify the terms using a script. */ script(scriptCode: string): TermsAggregation; /* Set to true to assume script values are unique. */ scriptValuesUnique(trueFalse: boolean): TermsAggregation; /* Determines how many terms the coordinating node will request from each shard. */ shardSize(shardSize: number): TermsAggregation; /* Sets the number of aggregation entries that will be returned. */ size(size: number): TermsAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the type of the field value for use in scripts. Current values are: string, double, float, long, integer, short, and byte. */ valueType(v: string): TermsAggregation; } /* A facet which returns the N most frequent terms within a collection or set of collections. Term facets are useful for building constructs which allow users to refine search results by filtering on terms returned by the facet. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. For more information on faceted navigation, see this Wikipedia article on Faceted Classification */ export class TermsFacet implements Facet { /* A facet which returns the N most frequent terms within a collection or set of collections. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Allows you to return all terms, even if the frequency count is 0. This should not be used on fields that contain a large number of unique terms because it could cause out-of-memory errors. */ allTerms(trueFalse: string): TermsFacet; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): TermsFacet; /* Allows you to filter out unwanted facet entries. When passed a single term, it is appended to the list of currently excluded terms. If passed an array, it overwrites all existing values. */ exclude(exclude: string | string[]): TermsFacet; /* Sets the execution hint determines how the facet is computed. Currently only supported value is "map". */ executionHint(h: Object): TermsFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): TermsFacet; /* Sets the field to be used to construct the this facet. Set to _index to return a facet count of hits per _index the search was executed on. */ field(fieldName: string): TermsFacet; /* Aggregate statistical info across a set of fields. */ fields(aFieldName: any[]): TermsFacet; /* Computes values across the entire index */ global(trueFalse: boolean): TermsFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): TermsFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): TermsFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): TermsFacet; /* Sets the type of ordering that will be performed on the date buckets. Valid values are: count - default, sort by the number of items in the bucket term - sort by term value. reverse_count - reverse sort of the number of items in the bucket reverse_term - reverse sort of the term value. */ order(o: string): TermsFacet; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): TermsFacet; /* Allows you to only include facet entries matching a specified regular expression. */ regex(exp: string): TermsFacet; /* Allows you to set the regular expression flags to be used with the regex */ regexFlags(flags: string): TermsFacet; /* Computes values across the the specified scope */ scope(scope: string): TermsFacet; /* Allows you modify the term using a script. The modified value is then used in the facet collection. */ script(scriptCode: string): TermsFacet; /* Sets a script that will provide the terms for a given document. */ scriptField(script: string): TermsFacet; /* Determines how many terms the coordinating node will request from each shard. */ shardSize(shardSize: number): TermsFacet; /* Sets the number of facet entries that will be returned for this facet. For instance, you might ask for only the top 5 authors although there might be hundreds of unique authors. */ size(facetSize: number): TermsFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Filters documents that have fields that match any of the provided terms (not analyzed) */ export class TermsFilter implements Filter { /* A Filter that matches documents containing provided terms. */ constructor(field: string, terms: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): TermsFilter; /* Sets the cache key. */ cacheKey(key: string): TermsFilter; /* Enable or disable caching of the lookup */ cacheLookup(trueFalse: boolean): TermsFilter; /* Sets the way terms filter executes is by iterating over the terms provided and finding matches docs (loading into a bitset) and caching it. Valid values are: plain, bool, bool_nocache, and, and_nocache, or, or_nocache. Defaults to plain. */ execution(e: string): TermsFilter; /* Sets the fields to filter against. */ field(f: string): TermsFilter; /* Sets the document id of the document containing the terms to use when performing a terms lookup. */ id(id: string): TermsFilter; /* Sets the index the document containing the terms is in when performing a terms lookup. Defaults to the index currently being searched. */ index(idx: string): TermsFilter; /* Sets the filter name. */ name(name: string): TermsFilter; /* Sets the path/field name where the terms in the source document are located when performing a terms lookup. */ path(path: string): TermsFilter; /* Sets the routing value for the source document when performing a terms lookup. */ routing(path: string): TermsFilter; /* Sets the terms. If t is a String, it is added to the existing list of terms. If t is an array, the list of terms replaces the existing terms. */ terms(t: string | string[]): TermsFilter; /* Returns the filter object. */ toJSON(): TermsFilter; /* Sets the type the document containing the terms when performing a terms lookup. */ type(type: string): TermsFilter; } /* A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. */ export class TermsQuery implements Query { /* A Query that matches documents containing provided terms. */ constructor(field: string, terms: string | string[]); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): TermsQuery; /* Enables or disables similarity coordinate scoring of documents matching the Query. Default: false. */ disableCoord(trueFalse: string): TermsQuery; /* Sets the fields to query against. */ field(f: string): TermsQuery; /* Sets the minimum number of terms that need to match in a document before that document is returned in the results. */ minimumShouldMatch(min: number): TermsQuery; /* Sets the terms. If you t is a String, it is added to the existing list of terms. If t is an array, the list of terms replaces the existing terms. */ terms(t: string | string[]): TermsQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* A termsStatsFacet allows you to compute statistics over an aggregate key (term). Essentially this facet provides the functionality of what is often refered to as a pivot table. Facets are similar to SQL GROUP BY statements but perform much better. You can also construct several "groups" at once by simply specifying multiple facets. Tip: For more information on faceted navigation, see this Wikipedia article on Faceted Classification. */ export class TermStatsFacet implements Facet { /* A facet which computes statistical data based on an aggregate key. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Allows you to return all terms, even if the frequency count is 0. This should not be used on fields that contain a large number of unique terms because it could cause out-of-memory errors. */ allTerms(trueFalse: string): TermStatsFacet; /* Enables caching of the facetFilter */ cacheFilter(trueFalse: boolean): TermStatsFacet; /* Allows you to reduce the documents used for computing facet results. */ facetFilter(oFilter: Object): TermStatsFacet; /* Computes values across the entire index */ global(trueFalse: boolean): TermStatsFacet; /* Sets the field which will be used to pivot on (group-by). */ keyField(fieldName: string): TermStatsFacet; /* The script language being used. Currently supported values are javascript, groovy, and mvel. */ lang(language: string): TermStatsFacet; /* Sets the mode the facet will use. collector post */ mode(m: string): TermStatsFacet; /* Sets the path to the nested document if faceting against a nested field. */ nested(path: string): TermStatsFacet; /* Sets the type of ordering that will be performed on the date buckets. Valid values are: count - default, sort by the number of items in the bucket term - sort by term value. reverse_count - reverse sort of the number of items in the bucket reverse_term - reverse sort of the term value. total - sorts by the total value of the bucket contents reverse_total - reverse sort of the total value of bucket contents min - the minimum value in the bucket reverse_min - the reverse sort of the minimum value max - the maximum value in the bucket reverse_max - the reverse sort of the maximum value mean - the mean value of the bucket contents reverse_mean - the reverse sort of the mean value of bucket contents. */ order(o: string): TermStatsFacet; /* Allows you to set script parameters to be used during the execution of the script. */ params(oParams: Object): TermStatsFacet; /* Computes values across the the specified scope */ scope(scope: string): TermStatsFacet; /* Sets a script that will provide the terms for a given document. */ scriptField(script: string): TermStatsFacet; /* Sets the number of facet entries that will be returned for this facet. For instance, you might ask for only the top 5 aggregate keys although there might be hundreds of unique keys. Higher settings could cause memory strain. */ size(facetSize: number): TermStatsFacet; /* Retrieves the internal facet object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the field for which statistical information will be generated. */ valueField(fieldName: string): TermStatsFacet; /* Define a script to evaluate of which the result will be used to generate the statistical information. */ valueScript(code: string): TermStatsFacet; } /* TermSuggester suggests terms based on edit distance. The provided suggest text is analyzed before terms are suggested. The suggested terms are provided per analyzed suggest text token. This leaves the suggest-selection to the API consumer. For a higher level suggester, please use the PhraseSuggester. */ export class TermSuggester implements Suggest { /* A suggester that suggests terms based on edit distance. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the accuracy. How similar the suggested terms at least need to be compared to the original suggest text. */ accuracy(a: number): TermSuggester; /* Sets analyzer used to analyze the suggest text. */ analyzer(analyzer: string): TermSuggester; /* Sets the field used to generate suggestions from. */ field(field: string): TermSuggester; /* Sets the maximum edit distance candidate suggestions can have in order to be considered as a suggestion. */ maxEdits(max: number): TermSuggester; /* The factor that is used to multiply with the size in order to inspect more candidate suggestions. */ maxInspections(max: number): TermSuggester; /* Sets a maximum threshold in number of documents a suggest text token can exist in order to be corrected. */ maxTermFreq(max: number): TermSuggester; /* Sets a minimal threshold of the number of documents a suggested term should appear in. */ minDocFreq(min: number): TermSuggester; /* Sets the minimum length a suggest text term must have in order to be corrected. */ minWordLen(len: number): TermSuggester; /* Sets the maximum number of suggestions to be retrieved from each individual shard. */ shardSize(s: number): TermSuggester; /* Sets the number of suggestions returned for each token. */ size(s: number): TermSuggester; /* Sets the sort mode. Valid values are: score - Sort by score first, then document frequency, and then the term itself frequency - Sort by document frequency first, then simlarity score and then the term itself */ sort(s: string): TermSuggester; /* Sets what string distance implementation to use for comparing how similar suggested terms are. Valid values are: internal - based on damerau_levenshtein but but highly optimized for comparing string distance for terms inside the index damerau_levenshtein - String distance algorithm based on Damerau-Levenshtein algorithm levenstein - String distance algorithm based on Levenstein edit distance algorithm jarowinkler - String distance algorithm based on Jaro-Winkler algorithm ngram - String distance algorithm based on character n-grams */ stringDistance(s: string): TermSuggester; /* Sets the suggest mode. Valid values are: missing - Only suggest terms in the suggest text that aren't in the index popular - Only suggest suggestions that occur in more docs then the original suggest text term always - Suggest any matching suggestions based on terms in the suggest text */ suggestMode(m: string): TermSuggester; /* Sets the text to get suggestions for. If not set, the global suggestion text will be used. */ text(txt: string): TermSuggester; /* Retrieves the internal suggest object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* TThe top_children query runs the child query with an estimated hits size, and out of the hit docs, aggregates it into parent docs. If there aren’t enough parent docs matching the requested from/size search request, then it is run again with a wider (more hits) search. The top_children also provide scoring capabilities, with the ability to specify max, sum or avg as the score type. */ export class TopChildrenQuery implements Query { /* Returns child documents matching the query aggregated into the parent docs. */ constructor(qry: Object, type: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: number): TopChildrenQuery; /* Sets the factor which is the number of hits that are asked for in the child query. Defaults to 5. */ factor(f: number): TopChildrenQuery; /* Sets the incremental factor. The incremental factor is used when not enough child documents are returned so the factor is multiplied by the incremental factor to fetch more results. Defaults to 52 */ incrementalFactor(f: number): TopChildrenQuery; /* Sets the query */ query(q: Object): TopChildrenQuery; /* Sets the scope of the query. A scope allows to run facets on the same scope name that will work against the child documents. */ scope(s: string): TopChildrenQuery; /* Sets the scoring type. Valid values are max, sum, or avg. If another value is passed it we silently ignore the value. */ score(s: string): TopChildrenQuery; /* Sets the scoring type. Valid values are max, sum, total, or avg. If another value is passed it we silently ignore the value. */ scoreMode(s: string): TopChildrenQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the child document type to search against */ type(t: string): TopChildrenQuery; } /* A Filter that filters results by a specified index type. */ export class TypeFilter implements Filter { /* Filter results by a specified index type. */ constructor(type: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Enable or disable caching of the filter */ cache(trueFalse: boolean): TypeFilter; /* Sets the cache key. */ cacheKey(key: string): TypeFilter; /* Sets the filter name. */ name(name: string): TypeFilter; /* Returns the filter object. */ toJSON(): TypeFilter; /* Sets the type */ type(type: string): TypeFilter; } /* A single-value metrics aggregation that counts the number of values that are extracted from the aggregated documents. These values can be extracted either from specific fields in the documents, or be generated by a provided script. Typically, this aggregator will be used in conjunction with other single-value aggregations. */ export class ValueCountAggregation implements Aggregation { /* Aggregation that counts the number of values that are extracted from the aggregated documents. */ constructor(name: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the field to operate on. */ field(field: string): ValueCountAggregation; /* The script language being used. */ lang(language: string): ValueCountAggregation; /* Sets parameters that will be applied to the script. Overwrites any existing params. */ params(p: Object): ValueCountAggregation; /* Allows you generate or modify the terms/values using a script. */ script(scriptCode: string): ValueCountAggregation; /* Set to true to assume script values are unique. */ scriptValuesUnique(trueFalse: boolean): ValueCountAggregation; /* Retrieves the internal agg object. This is typically used by internal API functions so use with caution. */ toJSON(): any; } /* Matches documents that have fields matching a wildcard expression (not analyzed). Supported wildcards are *, which matches any character sequence (including the empty one), and ?, which matches any single character. Note this query can be slow, as it needs to iterate over many wildcards. In order to prevent extremely slow wildcard queries, a wildcard wildcard should not start with one of the wildcards * or ?. The wildcard query maps to Lucene WildcardQuery. */ export class WildcardQuery implements Query { /* A Query that matches documents containing a wildcard. This may be combined with other wildcards with a BooleanQuery. */ constructor(field: string, value: string); /* The type of ejs object. For internal use only. */ _type(): string; /* Sets the boost value for documents matching the Query. */ boost(boost: Number): WildcardQuery; /* Sets the fields to query against. */ field(f: string): WildcardQuery; /* Sets rewrite method. Valid values are: constant_score_auto - tries to pick the best constant-score rewrite method based on term and document counts from the query scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query constant_score_boolean - same as scoring_boolean, expect no scores are computed. constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value. top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value. Default is constant_score_auto. This is an advanced option, use with care. */ rewrite(m: string): WildcardQuery; /* Retrieves the internal query object. This is typically used by internal API functions so use with caution. */ toJSON(): any; /* Sets the wildcard query value. */ value(v: string): WildcardQuery; } }