diff --git a/dsl/es-types.d.ts b/dsl/es-types.d.ts new file mode 100644 index 000000000..b1bb9e9ae --- /dev/null +++ b/dsl/es-types.d.ts @@ -0,0 +1,13892 @@ +declare namespace T { + export type Uri = string + + export interface Date { + } + + export type TimeSpan = string + + export interface SourceDocument { + } + + export interface ErrorCause { + additional_properties?: Record + bytes_limit?: long + bytes_wanted?: long + caused_by?: ErrorCause + column?: integer + failed_shards?: ShardFailure[] + grouped?: boolean + index?: string + index_uuid?: string + language?: string + licensed_expired_feature?: string + line?: integer + phase?: string + reason?: string + resource_id?: string[] + resource_type?: string + script?: string + script_stack?: string[] + shard?: integer | string + stack_trace?: string + type?: string + } + + export interface MainError extends ErrorCause { + headers?: Record + root_cause?: ErrorCause[] + } + + export type short = number + + export type byte = number + + export type integer = number + + export type long = number + + export type float = number + + export type double = number + + export type ScrollId = string + + export type ScrollIds = string + + export type CategoryId = string + + export type ActionIds = string + + export type Field = string + + export type Fields = string + + export type Id = string | number + + export type Ids = string | number | string[] + + export type IndexName = string + + export type Indices = string | string[] + + export type TypeName = string + + export type Types = string | string[] + + export type Routing = string | number + + export type LongId = string + + export type IndexMetrics = string + + export type Metrics = string + + export type Name = string + + export type Names = string + + export type NodeIds = string + + export type PropertyName = string + + export type RelationName = string + + export type TaskId = string + + export type Timestamp = string + + export interface Aggregate { + meta?: Record + } + + export interface Aggregation { + meta?: Record + name?: string + } + + export interface AggregationContainer { + adjacency_matrix?: AdjacencyMatrixAggregation + aggs?: Record + auto_date_histogram?: AutoDateHistogramAggregation + avg?: AverageAggregation + avg_bucket?: AverageBucketAggregation + boxplot?: BoxplotAggregation + bucket_script?: BucketScriptAggregation + bucket_selector?: BucketSelectorAggregation + bucket_sort?: BucketSortAggregation + cardinality?: CardinalityAggregation + children?: ChildrenAggregation + composite?: CompositeAggregation + cumulative_cardinality?: CumulativeCardinalityAggregation + cumulative_sum?: CumulativeSumAggregation + date_histogram?: DateHistogramAggregation + date_range?: DateRangeAggregation + derivative?: DerivativeAggregation + extended_stats?: ExtendedStatsAggregation + extended_stats_bucket?: ExtendedStatsBucketAggregation + filter?: FilterAggregation + filters?: FiltersAggregation + geo_bounds?: GeoBoundsAggregation + geo_centroid?: GeoCentroidAggregation + geo_distance?: GeoDistanceAggregation + geohash_grid?: GeoHashGridAggregation + geotile_grid?: GeoTileGridAggregation + global?: GlobalAggregation + histogram?: HistogramAggregation + ip_range?: IpRangeAggregation + matrix_stats?: MatrixStatsAggregation + max?: MaxAggregation + max_bucket?: MaxBucketAggregation + median_absolute_deviation?: MedianAbsoluteDeviationAggregation + meta?: Record + min?: MinAggregation + min_bucket?: MinBucketAggregation + missing?: MissingAggregation + moving_avg?: MovingAverageAggregation + moving_fn?: MovingFunctionAggregation + nested?: NestedAggregation + parent?: ParentAggregation + percentile_ranks?: PercentileRanksAggregation + percentiles?: PercentilesAggregation + percentiles_bucket?: PercentilesBucketAggregation + range?: RangeAggregation + rare_terms?: RareTermsAggregation + reverse_nested?: ReverseNestedAggregation + sampler?: SamplerAggregation + scripted_metric?: ScriptedMetricAggregation + serial_diff?: SerialDifferencingAggregation + significant_terms?: SignificantTermsAggregation + significant_text?: SignificantTextAggregation + stats?: StatsAggregation + stats_bucket?: StatsBucketAggregation + string_stats?: StringStatsAggregation + sum?: SumAggregation + sum_bucket?: SumBucketAggregation + terms?: TermsAggregation + top_hits?: TopHitsAggregation + top_metrics?: TopMetricsAggregation + value_count?: ValueCountAggregation + weighted_avg?: WeightedAverageAggregation + } + + export interface BucketAggregation { + aggregations?: Record + } + + export interface AdjacencyMatrixAggregation { + filters?: Record + } + + export interface AutoDateHistogramAggregation { + buckets?: integer + field?: Field + format?: string + minimum_interval?: MinimumInterval + missing?: Date + offset?: string + params?: Record + script?: Script + time_zone?: string + } + + export interface ChildrenAggregation { + type?: RelationName + } + + export interface CompositeAggregation { + after?: Record + size?: integer + sources?: CompositeAggregationSource[] + } + + export interface CompositeAggregationSource { + field?: Field + missing_bucket?: boolean + name?: string + order?: SortOrder + source_type?: string + } + + export interface DateHistogramAggregation { + calendar_interval?: DateInterval | Time + extended_bounds?: ExtendedBounds + field?: Field + fixed_interval?: DateInterval | Time + format?: string + interval?: DateInterval | Time + min_doc_count?: integer + missing?: Date + offset?: string + order?: HistogramOrder + params?: Record + script?: Script + time_zone?: string + } + + export interface DateRangeAggregation { + field?: Field + format?: string + missing?: object + ranges?: DateRangeExpression[] + time_zone?: string + } + + export interface DateRangeExpression { + from?: DateMath + key?: string + to?: DateMath + } + + export interface FilterAggregation { + filter?: QueryContainer + } + + export interface FiltersAggregation { + filters?: Record | QueryContainer[] + other_bucket?: boolean + other_bucket_key?: string + } + + export interface GeoDistanceAggregation { + distance_type?: GeoDistanceType + field?: Field + origin?: GeoLocation + ranges?: AggregationRange[] + unit?: DistanceUnit + } + + export interface GeoHashGridAggregation { + bounds?: BoundingBox + field?: Field + precision?: GeoHashPrecision + shard_size?: integer + size?: integer + } + + export interface GeoTileGridAggregation { + field?: Field + precision?: GeoTilePrecision + shard_size?: integer + size?: integer + } + + export interface GlobalAggregation { + } + + export interface ExtendedBounds { + max?: T + min?: T + } + + export interface HistogramAggregation { + extended_bounds?: ExtendedBounds + field?: Field + interval?: double + min_doc_count?: integer + missing?: double + offset?: double + order?: HistogramOrder + script?: Script + } + + export interface HistogramOrder { + count_ascending?: HistogramOrder + count_descending?: HistogramOrder + key?: string + key_ascending?: HistogramOrder + key_descending?: HistogramOrder + order?: SortOrder + } + + export interface IpRangeAggregation { + field?: Field + ranges?: IpRangeAggregationRange[] + } + + export interface IpRangeAggregationRange { + from?: string + mask?: string + to?: string + } + + export interface MissingAggregation { + field?: Field + } + + export interface NestedAggregation { + path?: Field + } + + export interface ParentAggregation { + type?: RelationName + } + + export interface RangeAggregation { + field?: Field + ranges?: AggregationRange[] + script?: Script + } + + export interface RareTermsAggregation { + exclude?: TermsExclude + field?: Field + include?: TermsInclude + max_doc_count?: long + missing?: object + precision?: double + } + + export interface ReverseNestedAggregation { + path?: Field + } + + export interface SamplerAggregation { + execution_hint?: SamplerAggregationExecutionHint + max_docs_per_value?: integer + script?: Script + shard_size?: integer + } + + export interface IncludeExclude { + pattern?: string + values?: string[] + } + + export interface SignificantTermsAggregation { + background_filter?: QueryContainer + chi_square?: ChiSquareHeuristic + exclude?: IncludeExclude + execution_hint?: TermsAggregationExecutionHint + field?: Field + gnd?: GoogleNormalizedDistanceHeuristic + include?: IncludeExclude + min_doc_count?: long + mutual_information?: MutualInformationHeuristic + percentage?: PercentageScoreHeuristic + script_heuristic?: ScriptedHeuristic + shard_min_doc_count?: long + shard_size?: integer + size?: integer + } + + export interface ChiSquareHeuristic { + background_is_superset?: boolean + include_negatives?: boolean + } + + export interface GoogleNormalizedDistanceHeuristic { + background_is_superset?: boolean + } + + export interface MutualInformationHeuristic { + background_is_superset?: boolean + include_negatives?: boolean + } + + export interface PercentageScoreHeuristic { + } + + export interface ScriptedHeuristic { + script?: Script + } + + export interface SignificantTextAggregation { + background_filter?: QueryContainer + chi_square?: ChiSquareHeuristic + exclude?: IncludeExclude + execution_hint?: TermsAggregationExecutionHint + field?: Field + filter_duplicate_text?: boolean + gnd?: GoogleNormalizedDistanceHeuristic + include?: IncludeExclude + min_doc_count?: long + mutual_information?: MutualInformationHeuristic + percentage?: PercentageScoreHeuristic + script_heuristic?: ScriptedHeuristic + shard_min_doc_count?: long + shard_size?: integer + size?: integer + source_fields?: Field[] + } + + export interface TermsAggregation { + collect_mode?: TermsAggregationCollectMode + exclude?: TermsExclude + execution_hint?: TermsAggregationExecutionHint + field?: Field + include?: TermsInclude + min_doc_count?: integer + missing?: object + order?: TermsOrder[] + script?: Script + shard_size?: integer + show_term_doc_count_error?: boolean + size?: integer + } + + export interface TermsExclude { + pattern?: string + values?: string[] + } + + export interface TermsInclude { + num_partitions?: long + partition?: long + pattern?: string + values?: string[] + } + + export interface TermsOrder { + count_ascending?: TermsOrder + count_descending?: TermsOrder + key?: string + key_ascending?: TermsOrder + key_descending?: TermsOrder + order?: SortOrder + } + + export interface MatrixAggregation { + fields?: Field[] + missing?: Record + } + + export interface MatrixStatsAggregation { + mode?: MatrixStatsMode + } + + export interface FormattableMetricAggregation { + format?: string + } + + export interface MetricAggregation { + field?: Field + missing?: double + script?: Script + } + + export interface AverageAggregation { + } + + export interface BoxplotAggregation { + compression?: double + } + + export interface CardinalityAggregation { + precision_threshold?: integer + rehash?: boolean + } + + export interface ExtendedStatsAggregation { + sigma?: double + } + + export interface GeoBoundsAggregation { + wrap_longitude?: boolean + } + + export interface GeoCentroidAggregation { + } + + export interface MaxAggregation { + } + + export interface MedianAbsoluteDeviationAggregation { + compression?: double + } + + export interface MinAggregation { + } + + export interface PercentileRanksAggregation { + keyed?: boolean + method?: PercentilesMethod + values?: double[] + } + + export interface PercentilesAggregation { + keyed?: boolean + method?: PercentilesMethod + percents?: double[] + } + + export interface PercentilesMethod { + } + + export interface ScriptedMetricAggregation { + combine_script?: Script + init_script?: Script + map_script?: Script + params?: Record + reduce_script?: Script + } + + export interface StatsAggregation { + } + + export interface StringStatsAggregation { + field?: Field + missing?: object + script?: Script + show_distribution?: boolean + } + + export interface SumAggregation { + } + + export interface TopHitsAggregation { + docvalue_fields?: Field[] + explain?: boolean + from?: integer + highlight?: Highlight + script_fields?: Record + size?: integer + sort?: Sort[] + _source?: boolean | SourceFilter + stored_fields?: Field[] + track_scores?: boolean + version?: boolean + } + + export interface TopMetricsAggregation { + metrics?: TopMetricsValue[] + size?: integer + sort?: Sort[] + } + + export interface TopMetricsValue { + field?: Field + } + + export interface ValueCountAggregation { + } + + export interface WeightedAverageAggregation { + format?: string + value?: WeightedAverageValue + value_type?: ValueType + weight?: WeightedAverageValue + } + + export interface WeightedAverageValue { + field?: Field + missing?: double + script?: Script + } + + export interface BucketsPath { + } + + export interface PipelineAggregation { + buckets_path?: BucketsPath + format?: string + gap_policy?: GapPolicy + } + + export interface AverageBucketAggregation { + } + + export interface BucketScriptAggregation { + script?: Script + } + + export interface BucketSelectorAggregation { + script?: Script + } + + export interface BucketSortAggregation { + from?: integer + gap_policy?: GapPolicy + size?: integer + sort?: Sort[] + } + + export interface CumulativeCardinalityAggregation { + } + + export interface CumulativeSumAggregation { + } + + export interface DerivativeAggregation { + } + + export interface ExtendedStatsBucketAggregation { + sigma?: double + } + + export interface MaxBucketAggregation { + } + + export interface MinBucketAggregation { + } + + export interface MovingAverageAggregation { + minimize?: boolean + model?: MovingAverageModel + predict?: integer + window?: integer + } + + export interface MovingAverageModel { + name?: string + } + + export interface MovingFunctionAggregation { + script?: string + shift?: integer + window?: integer + } + + export interface PercentilesBucketAggregation { + percents?: double[] + } + + export interface SerialDifferencingAggregation { + lag?: integer + } + + export interface StatsBucketAggregation { + } + + export interface SumBucketAggregation { + } + + export type StopWords = string | string[] + + export interface AnalyzerBase { + type?: string + version?: string + } + + export interface CustomAnalyzer extends AnalyzerBase { + char_filter?: string[] + filter?: string[] + position_increment_gap?: integer + position_offset_gap?: integer + tokenizer?: string + } + + export interface FingerprintAnalyzer extends AnalyzerBase { + max_output_size?: integer + preserve_original?: boolean + separator?: string + stopwords?: StopWords + stopwords_path?: string + } + + export interface KeywordAnalyzer extends AnalyzerBase { + } + + export interface LanguageAnalyzer extends AnalyzerBase { + language?: Language + stem_exclusion?: string[] + stopwords?: StopWords + stopwords_path?: string + type?: string + } + + export interface NoriAnalyzer extends AnalyzerBase { + decompound_mode?: NoriDecompoundMode + stoptags?: string[] + user_dictionary?: string + } + + export interface PatternAnalyzer extends AnalyzerBase { + flags?: string + lowercase?: boolean + pattern?: string + stopwords?: StopWords + } + + export interface SimpleAnalyzer extends AnalyzerBase { + } + + export interface SnowballAnalyzer extends AnalyzerBase { + language?: SnowballLanguage + stopwords?: StopWords + } + + export interface StandardAnalyzer extends AnalyzerBase { + max_token_length?: integer + stopwords?: StopWords + } + + export interface StopAnalyzer extends AnalyzerBase { + stopwords?: StopWords + stopwords_path?: string + } + + export interface WhitespaceAnalyzer extends AnalyzerBase { + } + + export interface CharFilterBase extends ICharFilter { + type?: string + version?: string + } + + export interface HtmlStripCharFilter extends CharFilterBase { + } + + export interface ICharFilter { + type?: string + version?: string + } + + export interface MappingCharFilter extends CharFilterBase { + mappings?: string[] + mappings_path?: string + } + + export interface PatternReplaceCharFilter extends CharFilterBase { + flags?: string + pattern?: string + replacement?: string + } + + export interface IcuAnalyzer extends AnalyzerBase { + method?: IcuNormalizationType + mode?: IcuNormalizationMode + } + + export interface IcuCollationTokenFilter extends TokenFilterBase { + alternate?: IcuCollationAlternate + caseFirst?: IcuCollationCaseFirst + caseLevel?: boolean + country?: string + decomposition?: IcuCollationDecomposition + hiraganaQuaternaryMode?: boolean + language?: string + numeric?: boolean + strength?: IcuCollationStrength + variableTop?: string + variant?: string + } + + export interface IcuFoldingTokenFilter extends TokenFilterBase { + unicode_set_filter?: string + } + + export interface IcuNormalizationCharFilter extends CharFilterBase { + mode?: IcuNormalizationMode + name?: IcuNormalizationType + } + + export interface IcuNormalizationTokenFilter extends TokenFilterBase { + name?: IcuNormalizationType + } + + export interface IcuTokenizer extends TokenizerBase { + rule_files?: string + } + + export interface IcuTransformTokenFilter extends TokenFilterBase { + dir?: IcuTransformDirection + id?: string + } + + export interface KuromojiAnalyzer extends AnalyzerBase { + mode?: KuromojiTokenizationMode + user_dictionary?: string + } + + export interface KuromojiIterationMarkCharFilter extends CharFilterBase { + normalize_kana?: boolean + normalize_kanji?: boolean + } + + export interface KuromojiPartOfSpeechTokenFilter extends TokenFilterBase { + stoptags?: string[] + } + + export interface KuromojiReadingFormTokenFilter extends TokenFilterBase { + use_romaji?: boolean + } + + export interface KuromojiStemmerTokenFilter extends TokenFilterBase { + minimum_length?: integer + } + + export interface KuromojiTokenizer extends TokenizerBase { + discard_punctuation?: boolean + mode?: KuromojiTokenizationMode + nbest_cost?: integer + nbest_examples?: string + user_dictionary?: string + user_dictionary_rules?: string[] + } + + export interface PhoneticTokenFilter extends TokenFilterBase { + encoder?: PhoneticEncoder + languageset?: PhoneticLanguage[] + max_code_len?: integer + name_type?: PhoneticNameType + replace?: boolean + rule_type?: PhoneticRuleType + } + + export interface AsciiFoldingTokenFilter extends TokenFilterBase { + preserve_original?: boolean + } + + export interface CommonGramsTokenFilter extends TokenFilterBase { + common_words?: string[] + common_words_path?: string + ignore_case?: boolean + query_mode?: boolean + } + + export interface ConditionTokenFilter extends TokenFilterBase { + filter?: string[] + script?: Script + } + + export interface ElisionTokenFilter extends TokenFilterBase { + articles?: string[] + articles_case?: boolean + } + + export interface FingerprintTokenFilter extends TokenFilterBase { + max_output_size?: integer + separator?: string + } + + export interface HunspellTokenFilter extends TokenFilterBase { + dedup?: boolean + dictionary?: string + locale?: string + longest_only?: boolean + } + + export interface ITokenFilter { + type?: string + version?: string + } + + export interface KStemTokenFilter extends TokenFilterBase { + } + + export interface KeepTypesTokenFilter extends TokenFilterBase { + mode?: KeepTypesMode + types?: string[] + } + + export interface KeepWordsTokenFilter extends TokenFilterBase { + keep_words?: string[] + keep_words_case?: boolean + keep_words_path?: string + } + + export interface KeywordMarkerTokenFilter extends TokenFilterBase { + ignore_case?: boolean + keywords?: string[] + keywords_path?: string + keywords_pattern?: string + } + + export interface LengthTokenFilter extends TokenFilterBase { + max?: integer + min?: integer + } + + export interface LimitTokenCountTokenFilter extends TokenFilterBase { + consume_all_tokens?: boolean + max_token_count?: integer + } + + export interface LowercaseTokenFilter extends TokenFilterBase { + language?: string + } + + export interface MultiplexerTokenFilter extends TokenFilterBase { + filters?: string[] + preserve_original?: boolean + } + + export interface NGramTokenFilter extends TokenFilterBase { + max_gram?: integer + min_gram?: integer + } + + export interface NoriPartOfSpeechTokenFilter extends TokenFilterBase { + stoptags?: string[] + } + + export interface PatternCaptureTokenFilter extends TokenFilterBase { + patterns?: string[] + preserve_original?: boolean + } + + export interface PatternReplaceTokenFilter extends TokenFilterBase { + flags?: string + pattern?: string + replacement?: string + } + + export interface PorterStemTokenFilter extends TokenFilterBase { + } + + export interface PredicateTokenFilter extends TokenFilterBase { + script?: Script + } + + export interface RemoveDuplicatesTokenFilter extends TokenFilterBase { + } + + export interface ReverseTokenFilter extends TokenFilterBase { + } + + export interface SnowballTokenFilter extends TokenFilterBase { + language?: SnowballLanguage + } + + export interface StemmerOverrideTokenFilter extends TokenFilterBase { + rules?: string[] + rules_path?: string + } + + export interface StemmerTokenFilter extends TokenFilterBase { + language?: string + } + + export interface TokenFilterBase extends ITokenFilter { + type?: string + version?: string + } + + export interface TrimTokenFilter extends TokenFilterBase { + } + + export interface TruncateTokenFilter extends TokenFilterBase { + length?: integer + } + + export interface UniqueTokenFilter extends TokenFilterBase { + only_on_same_position?: boolean + } + + export interface UppercaseTokenFilter extends TokenFilterBase { + } + + export interface CompoundWordTokenFilterBase extends TokenFilterBase { + hyphenation_patterns_path?: string + max_subword_size?: integer + min_subword_size?: integer + min_word_size?: integer + only_longest_match?: boolean + word_list?: string[] + word_list_path?: string + } + + export interface DictionaryDecompounderTokenFilter extends CompoundWordTokenFilterBase { + } + + export interface HyphenationDecompounderTokenFilter extends CompoundWordTokenFilterBase { + } + + export interface DelimitedPayloadTokenFilter extends TokenFilterBase { + delimiter?: string + encoding?: DelimitedPayloadEncoding + } + + export interface EdgeNGramTokenFilter extends TokenFilterBase { + max_gram?: integer + min_gram?: integer + side?: EdgeNGramSide + } + + export interface ShingleTokenFilter extends TokenFilterBase { + filler_token?: string + max_shingle_size?: integer + min_shingle_size?: integer + output_unigrams?: boolean + output_unigrams_if_no_shingles?: boolean + token_separator?: string + } + + export interface StopTokenFilter extends TokenFilterBase { + ignore_case?: boolean + remove_trailing?: boolean + stopwords?: StopWords + stopwords_path?: string + } + + export interface SynonymGraphTokenFilter extends TokenFilterBase { + expand?: boolean + format?: SynonymFormat + lenient?: boolean + synonyms?: string[] + synonyms_path?: string + tokenizer?: string + updateable?: boolean + } + + export interface SynonymTokenFilter extends TokenFilterBase { + expand?: boolean + format?: SynonymFormat + lenient?: boolean + synonyms?: string[] + synonyms_path?: string + tokenizer?: string + updateable?: boolean + } + + export interface WordDelimiterTokenFilter extends TokenFilterBase { + catenate_all?: boolean + catenate_numbers?: boolean + catenate_words?: boolean + generate_number_parts?: boolean + generate_word_parts?: boolean + preserve_original?: boolean + protected_words?: string[] + protected_words_path?: string + split_on_case_change?: boolean + split_on_numerics?: boolean + stem_english_possessive?: boolean + type_table?: string[] + type_table_path?: string + } + + export interface WordDelimiterGraphTokenFilter extends TokenFilterBase { + adjust_offsets?: boolean + catenate_all?: boolean + catenate_numbers?: boolean + catenate_words?: boolean + generate_number_parts?: boolean + generate_word_parts?: boolean + preserve_original?: boolean + protected_words?: string[] + protected_words_path?: string + split_on_case_change?: boolean + split_on_numerics?: boolean + stem_english_possessive?: boolean + type_table?: string[] + type_table_path?: string + } + + export interface CharGroupTokenizer extends TokenizerBase { + tokenize_on_chars?: string[] + } + + export interface ITokenizer { + type?: string + version?: string + } + + export interface KeywordTokenizer extends TokenizerBase { + buffer_size?: integer + } + + export interface LetterTokenizer extends TokenizerBase { + } + + export interface LowercaseTokenizer extends TokenizerBase { + } + + export interface NoriTokenizer extends TokenizerBase { + decompound_mode?: NoriDecompoundMode + discard_punctuation?: boolean + user_dictionary?: string + user_dictionary_rules?: string[] + } + + export interface PathHierarchyTokenizer extends TokenizerBase { + buffer_size?: integer + delimiter?: string + replacement?: string + reverse?: boolean + skip?: integer + } + + export interface PatternTokenizer extends TokenizerBase { + flags?: string + group?: integer + pattern?: string + } + + export interface StandardTokenizer extends TokenizerBase { + max_token_length?: integer + } + + export interface TokenizerBase extends ITokenizer { + type?: string + version?: string + } + + export interface UaxEmailUrlTokenizer extends TokenizerBase { + max_token_length?: integer + } + + export interface WhitespaceTokenizer extends TokenizerBase { + max_token_length?: integer + } + + export interface EdgeNGramTokenizer extends TokenizerBase { + custom_token_chars?: string + max_gram?: integer + min_gram?: integer + token_chars?: TokenChar[] + } + + export interface NGramTokenizer extends TokenizerBase { + custom_token_chars?: string + max_gram?: integer + min_gram?: integer + token_chars?: TokenChar[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatResponse { + records?: TCatRecord[] + } + + export interface ICatRecord { + } + + export interface CatAliasesRecord extends ICatRecord { + alias?: string + filter?: string + index?: string + indexRouting?: string + searchRouting?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatAliasesRequest extends RequestBase { + name?: Names + expand_wildcards?: ExpandWildcards + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatAliasesResponse { + records?: CatAliasesRecord[] + } + + export interface CatAllocationRecord extends ICatRecord { + "disk.avail"?: string + "disk.indices"?: string + "disk.percent"?: string + disk_ratio?: string + "disk.total"?: string + "disk.used"?: string + host?: string + ip?: string + node?: string + shards?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatAllocationRequest extends RequestBase { + node_id?: NodeIds + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatAllocationResponse { + records?: CatAllocationRecord[] + } + + export interface CatCountRecord extends ICatRecord { + count?: string + epoch?: string + timestamp?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatCountRequest extends RequestBase { + index?: Indices + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatCountResponse { + records?: CatCountRecord[] + } + + export interface CatDataFrameAnalyticsRecord extends ICatRecord { + assignment_explanation?: string + create_time?: string + description?: string + dest_index?: string + failure_reason?: string + id?: string + model_memory_limit?: string + "node.address"?: string + "node.ephemeral_id"?: string + "node.id"?: string + "node.name"?: string + progress?: string + source_index?: string + state?: string + type?: string + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatDataFrameAnalyticsRequest extends RequestBase { + id?: Id + allow_no_match?: boolean + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatDataFrameAnalyticsResponse { + records?: CatDataFrameAnalyticsRecord[] + } + + export interface CatDatafeedsRecord extends ICatRecord { + assignment_explanation?: string + "buckets.count"?: string + id?: string + "node.address"?: string + "node.ephemeral_id"?: string + "node.id"?: string + "node.name"?: string + "search.bucket_avg"?: string + "search.count"?: string + "search.exp_avg_hour"?: string + "search.time"?: string + state?: DatafeedState + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatDatafeedsRequest extends RequestBase { + datafeed_id?: Id + allow_no_datafeeds?: boolean + format?: string + headers?: string[] + help?: boolean + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatDatafeedsResponse { + records?: CatDatafeedsRecord[] + } + + export interface CatFielddataRecord extends ICatRecord { + field?: string + host?: string + id?: string + ip?: string + node?: string + size?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatFielddataRequest extends RequestBase { + fields?: Fields + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatFielddataResponse { + records?: CatFielddataRecord[] + } + + export interface CatHealthRecord extends ICatRecord { + cluster?: string + epoch?: string + init?: string + "node.data"?: string + "node.total"?: string + pending_tasks?: string + pri?: string + relo?: string + shards?: string + status?: string + timestamp?: string + unassign?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatHealthRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + include_timestamp?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatHealthResponse { + records?: CatHealthRecord[] + } + + export interface CatHelpRecord extends ICatRecord { + endpoint?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatHelpRequest extends RequestBase { + help?: boolean + sort_by_columns?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatHelpResponse { + records?: CatHelpRecord[] + } + + export interface CatIndicesRecord extends ICatRecord { + "docs.count"?: string + "docs.deleted"?: string + health?: string + index?: string + pri?: string + "pri.store.size"?: string + rep?: string + status?: string + "store.size"?: string + tm?: string + uuid?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatIndicesRequest extends RequestBase { + index?: Indices + bytes?: Bytes + expand_wildcards?: ExpandWildcards + format?: string + headers?: string[] + health?: Health + help?: boolean + include_unloaded_segments?: boolean + local?: boolean + master_timeout?: Time + pri?: boolean + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatIndicesResponse { + records?: CatIndicesRecord[] + } + + export interface CatJobsRecord extends ICatRecord { + assignment_explanation?: string + "buckets.count"?: string + "buckets.time.exp_avg"?: string + "buckets.time.exp_avg_hour"?: string + "buckets.time.max"?: string + "buckets.time.min"?: string + "buckets.time.total"?: string + "data.buckets"?: string + "data.earliest_record"?: string + "data.empty_buckets"?: string + "data.input_bytes"?: string + "data.input_fields"?: string + "data.input_records"?: string + "data.invalid_dates"?: string + "data.last"?: string + "data.last_empty_bucket"?: string + "data.last_sparse_bucket"?: string + "data.latest_record"?: string + "data.missing_fields"?: string + "data.out_of_order_timestamps"?: string + "data.processed_fields"?: string + "data.processed_records"?: string + "data.sparse_buckets"?: string + "forecasts.memory.avg"?: string + "forecasts.memory.min"?: string + "forecasts.memory.total"?: string + "forecasts.records.avg"?: string + "forecasts.records.max"?: string + "forecasts.records.min"?: string + "forecasts.records.total"?: string + "forecasts.time.avg"?: string + "forecasts.time.max"?: string + "forecasts.time.min"?: string + "forecasts.total"?: string + id?: string + "model.bucket_allocation_failures"?: string + "model.by_fields"?: string + "model.bytes"?: string + "model.categorization_status"?: ModelCategorizationStatus + "model.categorized_doc_count"?: string + "model.dead_category_count"?: string + "model.frequent_category_count"?: string + "model.log_time"?: string + "model.memory_limit"?: string + "model.memory_status"?: ModelMemoryStatus + "model.over_fields"?: string + "model.partition_fields"?: string + "model.rare_category_count"?: string + "model.timestamp"?: string + "node.address"?: string + "node.ephemeral_id"?: string + "node.id"?: string + "node.name"?: string + opened_time?: string + state?: JobState + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatJobsRequest extends RequestBase { + job_id?: Id + allow_no_jobs?: boolean + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatJobsResponse { + records?: CatJobsRecord[] + } + + export interface CatMasterRecord extends ICatRecord { + id?: string + ip?: string + node?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatMasterRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatMasterResponse { + records?: CatMasterRecord[] + } + + export interface CatNodeAttributesRecord extends ICatRecord { + attr?: string + host?: string + id?: string + ip?: string + node?: string + port?: long + pid?: long + value?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatNodeAttributesRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatNodeAttributesResponse { + records?: CatNodeAttributesRecord[] + } + + export interface CatNodesRecord extends ICatRecord { + build?: string + completion_size?: string + cpu?: string + disk_available?: string + fielddata_evictions?: string + fielddata_memory?: string + file_descriptor_current?: integer + file_descriptor_max?: integer + file_descriptor_percent?: integer + filter_cache_evictions?: string + filter_cache_memory?: string + flush_total?: string + flush_total_time?: string + get_current?: string + get_exists_time?: string + get_exists_total?: string + get_missing_time?: string + get_missing_total?: string + get_time?: string + get_total?: string + heap_current?: string + heap_max?: string + heap_percent?: string + id_cache_memory?: string + indexing_delete_current?: string + indexing_delete_time?: string + indexing_delete_total?: string + indexing_index_current?: string + indexing_index_time?: string + indexing_index_total?: string + ip?: string + jdk?: string + load_15m?: string + load_5m?: string + load_1m?: string + master?: string + merges_current?: string + merges_current_docs?: string + merges_current_size?: string + merges_total?: string + merges_total_docs?: string + merges_total_time?: string + name?: string + node_id?: string + node_role?: string + percolate_current?: string + percolate_memory?: string + percolate_queries?: string + percolate_time?: string + percolate_total?: string + pid?: string + port?: string + ram_current?: string + ram_max?: string + ram_percent?: string + refresh_time?: string + refresh_total?: string + search_fetch_current?: string + search_fetch_time?: string + search_fetch_total?: string + search_open_contexts?: string + search_query_current?: string + search_query_time?: string + search_query_total?: string + segments_count?: string + segments_index_writer_max_memory?: string + segments_index_writer_memory?: string + segments_memory?: string + segments_version_map_memory?: string + uptime?: string + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatNodesRequest extends RequestBase { + bytes?: Bytes + format?: string + full_id?: boolean + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatNodesResponse { + records?: CatNodesRecord[] + } + + export interface CatPendingTasksRecord extends ICatRecord { + insertOrder?: integer + priority?: string + source?: string + timeInQueue?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatPendingTasksRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatPendingTasksResponse { + records?: CatPendingTasksRecord[] + } + + export interface CatPluginsRecord extends ICatRecord { + component?: string + description?: string + id?: string + isolation?: string + name?: string + type?: string + url?: string + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatPluginsRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatPluginsResponse { + records?: CatPluginsRecord[] + } + + export interface CatRecoveryRecord extends ICatRecord { + bytes?: string + bytes_percent?: string + bytes_recovered?: string + bytes_total?: string + files?: string + files_percent?: string + files_recovered?: string + files_total?: string + index?: string + repository?: string + shard?: string + snapshot?: string + source_host?: string + source_node?: string + stage?: string + target_host?: string + target_node?: string + time?: string + translog_ops?: long + translog_ops_percent?: string + translog_ops_recovered?: long + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatRecoveryRequest extends RequestBase { + index?: Indices + active_only?: boolean + bytes?: Bytes + detailed?: boolean + format?: string + headers?: string[] + help?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatRecoveryResponse { + records?: CatRecoveryRecord[] + } + + export interface CatRepositoriesRecord extends ICatRecord { + id?: string + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatRepositoriesRequest extends RequestBase { + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatRepositoriesResponse { + records?: CatRepositoriesRecord[] + } + + export interface CatSegmentsRecord extends ICatRecord { + committed?: string + compound?: string + "docs.count"?: string + "docs.deleted"?: string + generation?: string + id?: string + index?: string + ip?: string + prirep?: string + searchable?: string + segment?: string + shard?: string + size?: string + "size.memory"?: string + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatSegmentsRequest extends RequestBase { + index?: Indices + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatSegmentsResponse { + records?: CatSegmentsRecord[] + } + + export interface CatShardsRecord extends ICatRecord { + "completion.size"?: string + docs?: string + "fielddata.evictions"?: string + "fielddata.memory_size"?: string + "filter_cache.memory_size"?: string + "flush.total"?: string + "flush.total_time"?: string + "get.current"?: string + "get.exists_time"?: string + "get.exists_total"?: string + "get.missing_time"?: string + "get.missing_total"?: string + "get.time"?: string + "get.total"?: string + id?: string + "id_cache.memory_size"?: string + index?: string + "indexing.delete_current"?: string + "indexing.delete_time"?: string + "indexing.delete_total"?: string + "indexing.index_current"?: string + "indexing.index_time"?: string + "indexing.index_total"?: string + ip?: string + "merges.current"?: string + "merges.current_docs"?: string + "merges.current_size"?: string + "merges.total_docs"?: string + "merges.total_size"?: string + "merges.total_time"?: string + node?: string + "percolate.current"?: string + "percolate.memory_size"?: string + "percolate.queries"?: string + "percolate.time"?: string + "percolate.total"?: string + prirep?: string + "refresh.time"?: string + "refresh.total"?: string + "search.fetch_current"?: string + "search.fetch_time"?: string + "search.fetch_total"?: string + "search.open_contexts"?: string + "search.query_current"?: string + "search.query_time"?: string + "search.query_total"?: string + "segments.count"?: string + "segments.fixed_bitset_memory"?: string + "segments.index_writer_max_memory"?: string + "segments.index_writer_memory"?: string + "segments.memory"?: string + "segments.version_map_memory"?: string + shard?: string + state?: string + store?: string + "warmer.current"?: string + "warmer.total"?: string + "warmer.total_time"?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatShardsRequest extends RequestBase { + index?: Indices + bytes?: Bytes + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatShardsResponse { + records?: CatShardsRecord[] + } + + export interface CatSnapshotsRecord extends ICatRecord { + duration?: Time + end_epoch?: long + end_time?: string + failed_shards?: long + id?: string + indices?: long + start_epoch?: long + start_time?: string + status?: string + successful_shards?: long + total_shards?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatSnapshotsRequest extends RequestBase { + repository?: Names + format?: string + headers?: string[] + help?: boolean + ignore_unavailable?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatSnapshotsResponse { + records?: CatSnapshotsRecord[] + } + + export interface CatTasksRecord extends ICatRecord { + action?: string + ip?: string + node?: string + parent_task_id?: string + running_time?: string + start_time?: string + task_id?: string + timestamp?: string + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTasksRequest extends RequestBase { + actions?: string[] + detailed?: boolean + format?: string + headers?: string[] + help?: boolean + node_id?: string[] + parent_task?: long + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTasksResponse { + records?: CatTasksRecord[] + } + + export interface CatTemplatesRecord extends ICatRecord { + index_patterns?: string + name?: string + order?: long + version?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTemplatesRequest extends RequestBase { + name?: Name + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTemplatesResponse { + records?: CatTemplatesRecord[] + } + + export interface CatThreadPoolRecord extends ICatRecord { + active?: integer + completed?: long + core?: integer + ephemeral_node_id?: string + host?: string + ip?: string + keep_alive?: Time + largest?: integer + max?: integer + name?: string + node_id?: string + node_name?: string + pool_size?: integer + port?: integer + pid?: integer + queue?: integer + queue_size?: integer + rejected?: long + size?: integer + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatThreadPoolRequest extends RequestBase { + thread_pool_patterns?: Names + format?: string + headers?: string[] + help?: boolean + local?: boolean + master_timeout?: Time + size?: Size + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatThreadPoolResponse { + records?: CatThreadPoolRecord[] + } + + export interface CatTrainedModelsRecord extends ICatRecord { + created_by?: string + create_time?: string + data_frame_analytics_id?: string + description?: string + heap_size?: string + id?: string + "ingest.count"?: long + "ingest.current"?: long + "ingest.failed"?: long + "ingest.pipelines"?: string + "ingest.time"?: long + license?: string + operations?: string + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTrainedModelsRequest extends RequestBase { + model_id?: Id + allow_no_match?: boolean + bytes?: Bytes + format?: string + from?: integer + headers?: string[] + help?: boolean + size?: integer + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTrainedModelsResponse { + records?: CatTrainedModelsRecord[] + } + + export interface CatTransformsRecord extends ICatRecord { + changes_last_detection_time?: string + checkpoint_duration_time_exp_avg?: long + create_time?: Date + description?: string + dest_index?: string + documents_indexed?: long + documents_processed?: long + frequency?: Time + id?: string + indexed_documents_exp_avg?: long + index_failure?: long + index_time?: long + index_total?: long + max_page_search_size?: long + pages_processed?: long + pipeline?: string + processed_documents_exp_avg?: long + processing_time?: long + reason?: string + search_failure?: long + search_time?: long + search_total?: long + source_index?: Indices + state?: TransformState + transform_type?: TransformType + trigger_count?: long + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTransformsRequest extends RequestBase { + transform_id?: Id + allow_no_match?: boolean + format?: string + from?: integer + headers?: string[] + help?: boolean + size?: integer + sort_by_columns?: string[] + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CatTransformsResponse { + records?: CatTransformsRecord[] + } + + export interface NodeStatistics { + failed?: integer + failures?: ErrorCause[] + successful?: integer + total?: integer + } + + export interface NodesResponseBase { + _nodes?: NodeStatistics + } + + export interface AllocationDecision { + decider?: string + decision?: AllocationExplainDecision + explanation?: string + } + + export interface AllocationStore { + allocation_id?: string + found?: boolean + in_sync?: boolean + matching_size_in_bytes?: long + matching_sync_id?: boolean + store_exception?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterAllocationExplainRequest extends RequestBase { + include_disk_info?: boolean + include_yes_decisions?: boolean + body?: { + index?: IndexName + primary?: boolean + shard?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterAllocationExplainResponse { + allocate_explanation?: string + allocation_delay?: string + allocation_delay_in_millis?: long + can_allocate?: Decision + can_move_to_other_node?: Decision + can_rebalance_cluster?: Decision + can_rebalance_cluster_decisions?: AllocationDecision[] + can_rebalance_to_other_node?: Decision + can_remain_decisions?: AllocationDecision[] + can_remain_on_current_node?: Decision + configured_delay?: string + configured_delay_in_mills?: long + current_node?: CurrentNode + current_state?: string + index?: string + move_explanation?: string + node_allocation_decisions?: NodeAllocationExplanation[] + primary?: boolean + rebalance_explanation?: string + remaining_delay?: string + remaining_delay_in_millis?: long + shard?: integer + unassigned_info?: UnassignedInformation + } + + export interface CurrentNode { + id?: string + name?: string + attributes?: Record + transport_address?: string + weight_ranking?: integer + } + + export interface NodeAllocationExplanation { + deciders?: AllocationDecision[] + node_attributes?: Record + node_decision?: Decision + node_id?: string + node_name?: string + store?: AllocationStore + transport_address?: string + weight_ranking?: integer + } + + export interface UnassignedInformation { + at?: Date + last_allocation_status?: string + reason?: UnassignedInformationReason + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterHealthRequest extends RequestBase { + index?: Indices + expand_wildcards?: ExpandWildcards + level?: Level + local?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + wait_for_events?: WaitForEvents + wait_for_nodes?: string + wait_for_no_initializing_shards?: boolean + wait_for_no_relocating_shards?: boolean + wait_for_status?: WaitForStatus + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterHealthResponse { + active_primary_shards?: integer + active_shards?: integer + active_shards_percent_as_number?: double + cluster_name?: string + delayed_unassigned_shards?: integer + indices?: Record + initializing_shards?: integer + number_of_data_nodes?: integer + number_of_in_flight_fetch?: integer + number_of_nodes?: integer + number_of_pending_tasks?: integer + relocating_shards?: integer + status?: Health + task_max_waiting_in_queue_millis?: long + timed_out?: boolean + unassigned_shards?: integer + } + + export interface IndexHealthStats { + active_primary_shards?: integer + active_shards?: integer + initializing_shards?: integer + number_of_replicas?: integer + number_of_shards?: integer + relocating_shards?: integer + shards?: Record + status?: Health + unassigned_shards?: integer + } + + export interface ShardHealthStats { + active_shards?: integer + initializing_shards?: integer + primary_active?: boolean + relocating_shards?: integer + status?: Health + unassigned_shards?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterPendingTasksRequest extends RequestBase { + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterPendingTasksResponse { + tasks?: PendingTask[] + } + + export interface PendingTask { + insert_order?: integer + priority?: string + source?: string + time_in_queue?: string + time_in_queue_millis?: integer + } + + export interface ClusterRerouteDecision { + decider?: string + decision?: string + explanation?: string + } + + export interface ClusterRerouteExplanation { + command?: string + decisions?: ClusterRerouteDecision[] + parameters?: ClusterRerouteParameters + } + + export interface ClusterRerouteParameters { + allow_primary?: boolean + from_node?: string + index?: string + node?: string + shard?: integer + to_node?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterRerouteRequest extends RequestBase { + dry_run?: boolean + explain?: boolean + master_timeout?: Time + metric?: string[] + retry_failed?: boolean + timeout?: Time + body?: { + commands?: ClusterRerouteCommand[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterRerouteResponse { + explanations?: ClusterRerouteExplanation[] + state?: string[] + } + + export interface ClusterRerouteCommand { + name?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterGetSettingsRequest extends RequestBase { + flat_settings?: boolean + include_defaults?: boolean + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterGetSettingsResponse { + persistent?: Record + transient?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterPutSettingsRequest extends RequestBase { + flat_settings?: boolean + master_timeout?: Time + timeout?: Time + body?: { + persistent?: Record + transient?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterPutSettingsResponse { + acknowledged?: boolean + persistent?: Record + transient?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterStateRequest extends RequestBase { + metric?: Metrics + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flat_settings?: boolean + ignore_unavailable?: boolean + local?: boolean + master_timeout?: Time + wait_for_metadata_version?: long + wait_for_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterStateResponse { + cluster_name?: string + cluster_uuid?: string + master_node?: string + state?: string[] + state_uuid?: string + version?: long + } + + export interface ClusterFileSystem { + available_in_bytes?: long + free_in_bytes?: long + total_in_bytes?: long + } + + export interface ClusterIndicesShardsIndexStats { + primaries?: ClusterShardMetrics + replication?: ClusterShardMetrics + shards?: ClusterShardMetrics + } + + export interface ClusterIndicesShardsStats { + index?: ClusterIndicesShardsIndexStats + primaries?: double + replication?: double + total?: double + } + + export interface ClusterIndicesStats { + completion?: CompletionStats + count?: long + docs?: DocStats + fielddata?: FielddataStats + query_cache?: QueryCacheStats + segments?: SegmentsStats + shards?: ClusterIndicesShardsStats + store?: StoreStats + } + + export interface ClusterIngestStats { + number_of_pipelines?: integer + processor_stats?: Record + } + + export interface ClusterJvm { + max_uptime_in_millis?: long + mem?: ClusterJvmMemory + threads?: long + versions?: ClusterJvmVersion[] + } + + export interface ClusterJvmMemory { + heap_max_in_bytes?: long + heap_used_in_bytes?: long + } + + export interface ClusterJvmVersion { + bundled_jdk?: boolean + count?: integer + using_bundled_jdk?: boolean + version?: string + vm_name?: string + vm_vendor?: string + vm_version?: string + } + + export interface ClusterNetworkTypes { + http_types?: Record + transport_types?: Record + } + + export interface ClusterNodeCount { + coordinating_only?: integer + data?: integer + ingest?: integer + master?: integer + total?: integer + voting_only?: integer + } + + export interface ClusterNodesStats { + count?: ClusterNodeCount + discovery_types?: Record + fs?: ClusterFileSystem + ingest?: ClusterIngestStats + jvm?: ClusterJvm + network_types?: ClusterNetworkTypes + os?: ClusterOperatingSystemStats + packaging_types?: NodePackagingType[] + plugins?: PluginStats[] + process?: ClusterProcess + versions?: string[] + } + + export interface ClusterOperatingSystemName { + count?: integer + name?: string + } + + export interface ClusterOperatingSystemStats { + allocated_processors?: integer + available_processors?: integer + mem?: OperatingSystemMemoryInfo + names?: ClusterOperatingSystemName[] + pretty_names?: ClusterOperatingSystemPrettyNane[] + } + + export interface ClusterProcess { + cpu?: ClusterProcessCpu + open_file_descriptors?: ClusterProcessOpenFileDescriptors + } + + export interface ClusterProcessCpu { + percent?: integer + } + + export interface ClusterProcessOpenFileDescriptors { + avg?: long + max?: long + min?: long + } + + export interface ClusterProcessorStats { + count?: long + current?: long + failed?: long + time_in_millis?: long + } + + export interface ClusterShardMetrics { + avg?: double + max?: double + min?: double + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterStatsRequest extends RequestBase { + node_id?: NodeIds + flat_settings?: boolean + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClusterStatsResponse extends NodesResponseBase { + cluster_name?: string + cluster_uuid?: string + indices?: ClusterIndicesStats + nodes?: ClusterNodesStats + status?: ClusterStatus + timestamp?: long + } + + export interface NodePackagingType { + count?: integer + flavor?: string + type?: string + } + + export interface OperatingSystemMemoryInfo { + free_in_bytes?: long + free_percent?: integer + total_in_bytes?: long + used_in_bytes?: long + used_percent?: integer + } + + export interface HotThreadInformation { + hosts?: string[] + node_id?: string + node_name?: string + threads?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesHotThreadsRequest extends RequestBase { + node_id?: NodeIds + ignore_idle_threads?: boolean + interval?: Time + snapshots?: long + threads?: long + thread_type?: ThreadType + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesHotThreadsResponse { + hot_threads?: HotThreadInformation[] + } + + export interface ClusterOperatingSystemPrettyNane { + count?: integer + pretty_name?: string + } + + export interface NodeInfo { + attributes?: Record + build_flavor?: string + build_hash?: string + build_type?: string + host?: string + http?: NodeInfoHttp + ip?: string + jvm?: NodeJvmInfo + name?: string + network?: NodeInfoNetwork + os?: NodeOperatingSystemInfo + plugins?: PluginStats[] + process?: NodeProcessInfo + roles?: NodeRole[] + settings?: string[] + thread_pool?: Record + total_indexing_buffer?: long + transport?: NodeInfoTransport + transport_address?: string + version?: string + } + + export interface NodeInfoHttp { + bound_address?: string[] + max_content_length?: string + max_content_length_in_bytes?: long + publish_address?: string + } + + export interface NodeInfoJvmMemory { + direct_max?: string + direct_max_in_bytes?: long + heap_init?: string + heap_init_in_bytes?: long + heap_max?: string + heap_max_in_bytes?: long + non_heap_init?: string + non_heap_init_in_bytes?: long + non_heap_max?: string + non_heap_max_in_bytes?: long + } + + export interface NodeInfoMemory { + total?: string + total_in_bytes?: long + } + + export interface NodeInfoNetwork { + primary_interface?: NodeInfoNetworkInterface + refresh_interval?: integer + } + + export interface NodeInfoNetworkInterface { + address?: string + mac_address?: string + name?: string + } + + export interface NodeInfoOSCPU { + cache_size?: string + cache_size_in_bytes?: integer + cores_per_socket?: integer + mhz?: integer + model?: string + total_cores?: integer + total_sockets?: integer + vendor?: string + } + + export interface NodeInfoTransport { + bound_address?: string[] + publish_address?: string + } + + export interface NodeJvmInfo { + gc_collectors?: string[] + mem?: NodeInfoJvmMemory + memory_pools?: string[] + pid?: integer + start_time_in_millis?: long + version?: string + vm_name?: string + vm_vendor?: string + vm_version?: string + } + + export interface NodeOperatingSystemInfo { + arch?: string + available_processors?: integer + cpu?: NodeInfoOSCPU + mem?: NodeInfoMemory + name?: string + pretty_name?: string + refresh_interval_in_millis?: integer + swap?: NodeInfoMemory + version?: string + } + + export interface NodeProcessInfo { + id?: long + mlockall?: boolean + refresh_interval_in_millis?: long + } + + export interface NodeThreadPoolInfo { + core?: integer + keep_alive?: string + max?: integer + queue_size?: integer + size?: integer + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesInfoRequest extends RequestBase { + node_id?: NodeIds + metric?: Metrics + flat_settings?: boolean + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesInfoResponse extends NodesResponseBase { + cluster_name?: string + nodes?: Record + } + + export interface AdaptiveSelectionStats { + avg_queue_size?: long + avg_response_time?: long + avg_response_time_ns?: long + avg_service_time?: string + avg_service_time_ns?: long + outgoing_searches?: long + rank?: string + } + + export interface BreakerStats { + estimated_size?: string + estimated_size_in_bytes?: long + limit_size?: string + limit_size_in_bytes?: long + overhead?: float + tripped?: float + } + + export interface CPUStats { + percent?: integer + sys?: string + sys_in_millis?: long + total?: string + total_in_millis?: long + user?: string + user_in_millis?: long + } + + export interface DataPathStats { + available?: string + available_in_bytes?: long + disk_queue?: string + disk_reads?: long + disk_read_size?: string + disk_read_size_in_bytes?: long + disk_writes?: long + disk_write_size?: string + disk_write_size_in_bytes?: long + free?: string + free_in_bytes?: long + mount?: string + path?: string + total?: string + total_in_bytes?: long + type?: string + } + + export interface ExtendedMemoryStats extends MemoryStats { + free_percent?: integer + used_percent?: integer + } + + export interface FileSystemStats { + data?: DataPathStats[] + timestamp?: long + total?: TotalFileSystemStats + } + + export interface GarbageCollectionGenerationStats { + collection_count?: long + collection_time?: string + collection_time_in_millis?: long + } + + export interface GarbageCollectionStats { + collectors?: Record + } + + export interface HttpStats { + current_open?: integer + total_opened?: long + } + + export interface JvmClassesStats { + current_loaded_count?: long + total_loaded_count?: long + total_unloaded_count?: long + } + + export interface JvmPool { + max?: string + max_in_bytes?: long + peak_max?: string + peak_max_in_bytes?: long + peak_used?: string + peak_used_in_bytes?: long + used?: string + used_in_bytes?: long + } + + export interface LoadAverageStats { + "15m"?: float + "5m"?: float + "1m"?: float + } + + export interface MemoryStats { + resident?: string + resident_in_bytes?: long + share?: string + share_in_bytes?: long + total_virtual?: string + total_virtual_in_bytes?: long + } + + export interface NodeBufferPool { + count?: long + total_capacity?: string + total_capacity_in_bytes?: long + used?: string + used_in_bytes?: long + } + + export interface NodeJvmStats { + buffer_pools?: Record + classes?: JvmClassesStats + gc?: GarbageCollectionStats + mem?: MemoryStats + threads?: ThreadStats + timestamp?: long + uptime?: string + uptime_in_millis?: long + } + + export interface NodeStats { + adaptive_selection?: Record + breakers?: Record + fs?: FileSystemStats + host?: string + http?: HttpStats + indices?: IndexStats + ingest?: NodeIngestStats + ip?: string[] + jvm?: NodeJvmStats + name?: string + os?: OperatingSystemStats + process?: ProcessStats + roles?: NodeRole[] + script?: ScriptStats + thread_pool?: Record + timestamp?: long + transport?: TransportStats + transport_address?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesStatsRequest extends RequestBase { + node_id?: NodeIds + metric?: Metrics + index_metric?: IndexMetrics + completion_fields?: Field[] + fielddata_fields?: Field[] + fields?: Field[] + groups?: boolean + include_segment_file_sizes?: boolean + level?: Level + timeout?: Time + types?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesStatsResponse extends NodesResponseBase { + cluster_name?: string + nodes?: Record + } + + export interface OperatingSystemStats { + cpu?: CPUStats + mem?: ExtendedMemoryStats + swap?: MemoryStats + timestamp?: long + } + + export interface ProcessStats { + cpu?: CPUStats + mem?: MemoryStats + open_file_descriptors?: integer + timestamp?: long + } + + export interface ScriptStats { + cache_evictions?: long + compilations?: long + } + + export interface ThreadCountStats { + active?: long + completed?: long + largest?: long + queue?: long + rejected?: long + threads?: long + } + + export interface ThreadStats { + count?: long + peak_count?: long + } + + export interface TotalFileSystemStats { + available?: string + available_in_bytes?: long + free?: string + free_in_bytes?: long + total?: string + total_in_bytes?: long + } + + export interface TransportStats { + rx_count?: long + rx_size?: string + rx_size_in_bytes?: long + server_open?: integer + tx_count?: long + tx_size?: string + tx_size_in_bytes?: long + } + + export interface IngestStats { + count?: long + current?: long + failed?: long + processors?: KeyedProcessorStats[] + time_in_millis?: long + } + + export interface KeyedProcessorStats { + statistics?: ProcessStats + type?: string + } + + export interface NodeIngestStats { + pipelines?: Record + total?: IngestStats + } + + export interface NodeUsageInformation { + rest_actions?: Record + since?: Date + timestamp?: Date + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesUsageRequest extends RequestBase { + node_id?: NodeIds + metric?: Metrics + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface NodesUsageResponse extends NodesResponseBase { + cluster_name?: string + nodes?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface PingRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface PingResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReloadSecureSettingsRequest extends RequestBase { + node_id?: NodeIds + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReloadSecureSettingsResponse extends NodesResponseBase { + cluster_name?: string + nodes?: Record + } + + export interface RemoteInfo { + connected?: boolean + initial_connect_timeout?: Time + max_connections_per_cluster?: integer + num_nodes_connected?: long + seeds?: string[] + skip_unavailable?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface RemoteInfoRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface RemoteInfoResponse extends Record { + } + + /** + * @description Stability: UNSTABLE + */ + export interface RootNodeInfoRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface RootNodeInfoResponse { + cluster_name?: string + cluster_uuid?: string + name?: string + tagline?: string + version?: ElasticsearchVersionInfo + } + + /** + * @description Stability: UNSTABLE + */ + export interface CancelTasksRequest extends RequestBase { + task_id?: TaskId + actions?: string[] + nodes?: string[] + parent_task_id?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CancelTasksResponse { + node_failures?: ErrorCause[] + nodes?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTaskRequest extends RequestBase { + task_id: TaskId + timeout?: Time + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTaskResponse { + completed?: boolean + task?: TaskInfo + } + + export interface TaskInfo { + action?: string + cancellable?: boolean + children?: TaskInfo[] + description?: string + headers?: Record + id?: long + node?: string + running_time_in_nanos?: long + start_time_in_millis?: long + status?: TaskStatus + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ListTasksRequest extends RequestBase { + actions?: string[] + detailed?: boolean + group_by?: GroupBy + nodes?: string[] + parent_task_id?: string + timeout?: Time + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ListTasksResponse { + node_failures?: ErrorCause[] + nodes?: Record + } + + export interface TaskExecutingNode { + attributes?: Record + host?: string + ip?: string + name?: string + roles?: string[] + tasks?: Record + transport_address?: string + } + + export interface TaskRetries { + bulk?: integer + search?: integer + } + + export interface TaskState { + action?: string + cancellable?: boolean + description?: string + headers?: Record + id?: long + node?: string + parent_task_id?: TaskId + running_time_in_nanos?: long + start_time_in_millis?: long + status?: TaskStatus + type?: string + } + + export interface TaskStatus { + batches?: long + created?: long + deleted?: long + noops?: long + requests_per_second?: float + retries?: TaskRetries + throttled_millis?: long + throttled_until_millis?: long + total?: long + updated?: long + version_conflicts?: long + } + + export interface CustomResponseBuilderBase { + } + + export interface Dictionary { + key?: TKey + value?: TValue + } + + export interface SingleKeyDictionary { + value?: TValue + } + + /** + * @description Stability: UNSTABLE + */ + export interface ElasticsearchResponse { + } + + export interface ElasticsearchUrlFormatter { + } + + export interface ShardFailure { + index?: string + node?: string + reason?: ErrorCause + shard?: integer + status?: string + } + + export interface UrlParameter { + } + + export interface LazyDocument { + } + + export interface RequestBase { + error_trace?: boolean + filter_path?: string | string[] + human?: boolean + pretty?: boolean + source_query_string?: string + } + + export interface AcknowledgedResponseBase { + acknowledged?: boolean + } + + export interface DynamicResponseBase { + } + + export interface ElasticsearchVersionInfo { + build_date?: Date + build_flavor?: string + build_hash?: string + build_snapshot?: boolean + build_type?: string + lucene_version?: string + minimum_index_compatibility_version?: string + minimum_wire_compatibility_version?: string + number?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ErrorResponse { + error?: MainError + status?: integer + } + + export interface IndicesResponseBase extends AcknowledgedResponseBase { + _shards?: ShardStatistics + } + + export interface ShardsOperationResponseBase { + _shards?: ShardStatistics + } + + export interface Union { + } + + export type DateMath = string + + export type DateMathExpression = string + + export interface DateMathTime { + factor?: integer + interval?: DateMathTimeUnit + } + + export interface Fuzziness { + auto?: boolean + edit_distance?: integer + high?: integer + low?: integer + ratio?: double + } + + export interface Distance { + precision?: double + unit?: DistanceUnit + } + + export interface ClusterStatistics { + skipped?: integer + successful?: integer + total?: integer + } + + export interface ShardStatistics { + failed?: integer + failures?: ShardFailure[] + successful?: integer + total?: integer + skipped?: integer + } + + export type MinimumShouldMatch = integer | string + + export interface AggregationRange { + from?: double + key?: string + to?: double + } + + export interface InlineScript { + source?: string + } + + export interface Script { + lang?: string + params?: Record + } + + export interface ScriptField { + script?: Script + } + + export interface CompletionStats { + size_in_bytes?: long + } + + export interface DocStats { + count?: long + deleted?: long + } + + export interface FielddataStats { + evictions?: long + memory_size_in_bytes?: long + } + + export interface FlushStats { + periodic?: long + total?: long + total_time?: string + total_time_in_millis?: long + } + + export interface GetStats { + current?: long + exists_time?: string + exists_time_in_millis?: long + exists_total?: long + missing_time?: string + missing_time_in_millis?: long + missing_total?: long + time?: string + time_in_millis?: long + total?: long + } + + export interface IndexingStats { + index_current?: long + delete_current?: long + delete_time?: string + delete_time_in_millis?: long + delete_total?: long + is_throttled?: boolean + noop_update_total?: long + throttle_time?: string + throttle_time_in_millis?: long + index_time?: string + index_time_in_millis?: long + index_total?: long + types?: Record + } + + export interface MergesStats { + current?: long + current_docs?: long + current_size?: string + current_size_in_bytes?: long + total?: long + total_auto_throttle?: string + total_auto_throttle_in_bytes?: long + total_docs?: long + total_size?: string + total_size_in_bytes?: long + total_stopped_time?: string + total__stopped_time_in_millis?: long + total_throttled_time?: string + total_throttled_time_in_millis?: long + total_time?: string + total_time_in_millis?: long + } + + export interface PluginStats { + classname?: string + description?: string + elasticsearch_version?: string + extended_plugins?: string[] + has_native_controller?: boolean + java_version?: string + name?: string + version?: string + } + + export interface QueryCacheStats { + cache_count?: long + cache_size?: long + evictions?: long + hit_count?: long + memory_size_in_bytes?: long + miss_count?: long + total_count?: long + } + + export interface RecoveryStats { + current_as_source?: long + current_as_target?: long + throttle_time?: string + throttle_time_in_millis?: long + } + + export interface RefreshStats { + external_total?: long + external_total_time_in_millis?: long + total?: long + total_time?: string + total_time_in_millis?: long + } + + export interface RequestCacheStats { + evictions?: long + hit_count?: long + memory_size?: string + memory_size_in_bytes?: long + miss_count?: long + } + + export interface SearchStats { + fetch_current?: long + fetch_time_in_millis?: long + fetch_total?: long + open_contexts?: long + query_current?: long + query_time_in_millis?: long + query_total?: long + scroll_current?: long + scroll_time_in_millis?: long + scroll_total?: long + suggest_current?: long + suggest_time_in_millis?: long + suggest_total?: long + } + + export interface SegmentsStats { + count?: long + doc_values_memory_in_bytes?: long + file_sizes?: Record + fixed_bit_set_memory_in_bytes?: long + index_writer_max_memory_in_bytes?: long + index_writer_memory_in_bytes?: long + max_unsafe_auto_id_timestamp?: long + memory_in_bytes?: long + norms_memory_in_bytes?: long + points_memory_in_bytes?: long + stored_fields_memory_in_bytes?: long + terms_memory_in_bytes?: long + term_vectors_memory_in_bytes?: long + version_map_memory_in_bytes?: long + } + + export interface StoreStats { + size?: string + size_in_bytes?: double + } + + export interface TranslogStats { + earliest_last_modified_age?: long + operations?: long + size?: string + size_in_bytes?: long + uncommitted_operations?: integer + uncommitted_size?: string + uncommitted_size_in_bytes?: long + } + + export interface WarmerStats { + current?: long + total?: long + total_time?: string + total_time_in_millis?: long + } + + export type Time = string + + export interface BulkIndexByScrollFailure { + cause?: MainError + id?: string + index?: string + status?: integer + type?: string + } + + export interface Retries { + bulk?: long + search?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface BulkRequest extends RequestBase { + index?: IndexName + type?: TypeName + pipeline?: string + refresh?: Refresh + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + timeout?: Time + type_query_string?: string + wait_for_active_shards?: string + body?: Array + } + + /** + * @description Stability: UNSTABLE + */ + export interface BulkResponse { + errors?: boolean + items?: BulkResponseItemContainer[] + took?: long + } + + export interface BulkOperation { + _id?: Id + _index?: IndexName + retry_on_conflict?: integer + routing?: Routing + version?: long + version_type?: VersionType + } + + export interface BulkOperationContainer { + index?: BulkIndexOperation + create?: BulkCreateOperation + update?: BulkUpdateOperation + delete?: BulkDeleteOperation + } + + export interface BulkIndexOperation extends BulkOperation { + } + + export interface BulkCreateOperation extends BulkOperation { + } + + export interface BulkUpdateOperation extends BulkOperation { + } + + export interface BulkDeleteOperation extends BulkOperation { + } + + export interface BulkResponseItemBase { + error?: MainError + _id?: string + _index?: string + _primary_term?: long + result?: string + _seq_no?: long + _shards?: ShardStatistics + status?: integer + _type?: string + _version?: long + forced_refresh?: boolean + get?: GetResponse + } + + export interface BulkResponseItemContainer { + index?: BulkIndexResponseItem + create?: BulkCreateResponseItem + update?: BulkUpdateResponseItem + delete?: BulkDeleteResponseItem + } + + export interface BulkIndexResponseItem extends BulkResponseItemBase { + } + + export interface BulkCreateResponseItem extends BulkResponseItemBase { + } + + export interface BulkUpdateResponseItem extends BulkResponseItemBase { + } + + export interface BulkDeleteResponseItem extends BulkResponseItemBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteByQueryRequest extends RequestBase { + index: Indices + type?: Types + allow_no_indices?: boolean + analyzer?: string + analyze_wildcard?: boolean + conflicts?: Conflicts + default_operator?: DefaultOperator + df?: string + expand_wildcards?: ExpandWildcards + from?: long + ignore_unavailable?: boolean + lenient?: boolean + preference?: string + query_on_query_string?: string + refresh?: boolean + request_cache?: boolean + requests_per_second?: long + routing?: Routing + scroll?: Time + scroll_size?: long + search_timeout?: Time + search_type?: SearchType + size?: long + slices?: long + sort?: string[] + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + stats?: string[] + terminate_after?: long + timeout?: Time + version?: boolean + wait_for_active_shards?: string + wait_for_completion?: boolean + body?: { + max_docs?: long + query?: QueryContainer + slice?: SlicedScroll + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteByQueryResponse { + batches?: long + deleted?: long + failures?: BulkIndexByScrollFailure[] + noops?: long + requests_per_second?: float + retries?: Retries + slice_id?: integer + task?: TaskId + throttled_millis?: long + throttled_until_millis?: long + timed_out?: boolean + took?: long + total?: long + version_conflicts?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteByQueryRethrottleRequest extends RequestBase { + task_id: TaskId + requests_per_second?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteByQueryRethrottleResponse extends ListTasksResponse { + } + + export interface MultiGetOperation { + can_be_flattened?: boolean + _id?: Id + _index?: IndexName + routing?: string + _source?: boolean | SourceFilter + stored_fields?: Field[] + version?: long + version_type?: VersionType + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiGetRequest extends RequestBase { + index?: IndexName + type?: TypeName + preference?: string + realtime?: boolean + refresh?: boolean + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + stored_fields?: Field[] + body?: { + docs?: MultiGetOperation[] + } + } + + export interface MultiGetHit { + error?: MainError + found?: boolean + id?: string + index?: string + primary_term?: long + routing?: string + sequence_number?: long + source?: TDocument + type?: string + version?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiGetResponse { + hits?: MultiGetHit[] + } + + export interface MultiTermVectorOperation { + doc?: object + fields?: Field[] + field_statistics?: boolean + filter?: TermVectorFilter + _id?: Id + _index?: IndexName + offsets?: boolean + payloads?: boolean + positions?: boolean + routing?: Routing + term_statistics?: boolean + version?: long + version_type?: VersionType + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiTermVectorsRequest extends RequestBase { + index?: IndexName + type?: TypeName + fields?: Field[] + field_statistics?: boolean + offsets?: boolean + payloads?: boolean + positions?: boolean + preference?: string + realtime?: boolean + routing?: Routing + term_statistics?: boolean + version?: long + version_type?: VersionType + body?: { + docs?: MultiTermVectorOperation[] + ids?: Id[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiTermVectorsResponse { + docs?: TermVectorsResult[] + } + + export interface ReindexDestination { + index?: IndexName + op_type?: OpType + pipeline?: string + routing?: ReindexRouting + version_type?: VersionType + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReindexOnServerRequest extends RequestBase { + refresh?: boolean + requests_per_second?: long + scroll?: Time + slices?: long + timeout?: Time + wait_for_active_shards?: string + wait_for_completion?: boolean + body?: { + conflicts?: Conflicts + dest?: ReindexDestination + max_docs?: long + script?: Script + size?: long + source?: ReindexSource + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReindexOnServerResponse { + batches?: long + created?: long + failures?: BulkIndexByScrollFailure[] + noops?: long + retries?: Retries + slice_id?: integer + task?: TaskId + timed_out?: boolean + took?: Time + total?: long + updated?: long + version_conflicts?: long + } + + export interface ReindexRouting { + } + + export interface ReindexSource { + index?: Indices + query?: QueryContainer + remote?: RemoteSource + size?: integer + slice?: SlicedScroll + sort?: Sort[] + _source?: Field[] + } + + export interface RemoteSource { + connect_timeout?: Time + host?: Uri + password?: string + socket_timeout?: Time + username?: string + } + + export interface ReindexNode { + attributes?: Record + host?: string + ip?: string + name?: string + roles?: string[] + tasks?: Record + transport_address?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReindexRethrottleRequest extends RequestBase { + task_id: TaskId + requests_per_second?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReindexRethrottleResponse { + nodes?: Record + } + + export interface ReindexStatus { + batches?: long + created?: long + deleted?: long + noops?: long + requests_per_second?: float + retries?: Retries + throttled_millis?: long + throttled_until_millis?: long + total?: long + updated?: long + version_conflicts?: long + } + + export interface ReindexTask { + action?: string + cancellable?: boolean + description?: string + id?: long + node?: string + running_time_in_nanos?: long + start_time_in_millis?: long + status?: ReindexStatus + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateByQueryRequest extends RequestBase { + index: Indices + type?: Types + allow_no_indices?: boolean + analyzer?: string + analyze_wildcard?: boolean + conflicts?: Conflicts + default_operator?: DefaultOperator + df?: string + expand_wildcards?: ExpandWildcards + from?: long + ignore_unavailable?: boolean + lenient?: boolean + pipeline?: string + preference?: string + query_on_query_string?: string + refresh?: boolean + request_cache?: boolean + requests_per_second?: long + routing?: Routing + scroll?: Time + scroll_size?: long + search_timeout?: Time + search_type?: SearchType + size?: long + slices?: long + sort?: string[] + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + stats?: string[] + terminate_after?: long + timeout?: Time + version?: boolean + version_type?: boolean + wait_for_active_shards?: string + wait_for_completion?: boolean + body?: { + max_docs?: long + query?: QueryContainer + script?: Script + slice?: SlicedScroll + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateByQueryResponse { + batches?: long + failures?: BulkIndexByScrollFailure[] + noops?: long + requests_per_second?: float + retries?: Retries + task?: TaskId + timed_out?: boolean + took?: long + total?: long + updated?: long + version_conflicts?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateByQueryRethrottleRequest extends RequestBase { + task_id: TaskId + requests_per_second?: long + } + + export interface WriteResponseBase { + _id?: string + _index?: string + _primary_term?: long + result?: Result + _seq_no?: long + _shards?: ShardStatistics + _type?: string + _version?: long + forced_refresh?: boolean + } + + /** + * @description Stability: STABLE + */ + export interface CreateRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + pipeline?: string + refresh?: Refresh + routing?: Routing + timeout?: Time + version?: long + version_type?: VersionType + wait_for_active_shards?: string + body?: TDocument + } + + /** + * @description Stability: STABLE + */ + export interface CreateResponse extends WriteResponseBase { + } + + /** + * @description Stability: STABLE + */ + export interface DeleteRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + if_primary_term?: long + if_seq_no?: long + refresh?: Refresh + routing?: Routing + timeout?: Time + version?: long + version_type?: VersionType + wait_for_active_shards?: string + } + + /** + * @description Stability: STABLE + */ + export interface DeleteResponse extends WriteResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DocumentExistsRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + preference?: string + realtime?: boolean + refresh?: boolean + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + stored_fields?: Field[] + version?: long + version_type?: VersionType + } + + /** + * @description Stability: STABLE + */ + export interface GetRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + preference?: string + realtime?: boolean + refresh?: boolean + routing?: Routing + source_enabled?: boolean + _source_excludes?: Field[] + _source_includes?: Field[] + stored_fields?: Field[] + version?: long + version_type?: VersionType + _source?: boolean | string | string[] + } + + /** + * @description Stability: STABLE + */ + export interface GetResponse { + fields?: Record + found?: boolean + _id?: string + _index?: string + _primary_term?: long + _routing?: string + _seq_no?: long + _source?: TDocument + _type?: string + _version?: long + } + + /** + * @description Stability: STABLE + */ + export interface IndexRequest extends RequestBase { + id?: Id + index: IndexName + type?: TypeName + if_primary_term?: long + if_seq_no?: long + op_type?: OpType + pipeline?: string + refresh?: Refresh + routing?: Routing + timeout?: Time + version?: long + version_type?: VersionType + wait_for_active_shards?: string + body?: TDocument + } + + /** + * @description Stability: STABLE + */ + export interface IndexResponse extends WriteResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface SourceRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + preference?: string + realtime?: boolean + refresh?: boolean + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + version?: long + version_type?: VersionType + } + + /** + * @description Stability: UNSTABLE + */ + export interface SourceResponse { + body?: TDocument + } + + /** + * @description Stability: UNSTABLE + */ + export interface SourceExistsRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + preference?: string + realtime?: boolean + refresh?: boolean + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + version?: long + version_type?: VersionType + } + + export interface FieldStatistics { + doc_count?: integer + sum_doc_freq?: long + sum_ttf?: long + } + + export interface TermVector { + field_statistics?: FieldStatistics + terms?: Record + } + + export interface TermVectorFilter { + max_doc_freq?: integer + max_num_terms?: integer + max_term_freq?: integer + max_word_length?: integer + min_doc_freq?: integer + min_term_freq?: integer + min_word_length?: integer + } + + export interface TermVectorTerm { + doc_freq?: integer + score?: double + term_freq?: integer + tokens?: Token[] + ttf?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface TermVectorsRequest extends RequestBase { + index: IndexName + id?: Id + type?: TypeName + fields?: Field[] + field_statistics?: boolean + offsets?: boolean + payloads?: boolean + positions?: boolean + preference?: string + realtime?: boolean + routing?: Routing + term_statistics?: boolean + version?: long + version_type?: VersionType + body?: { + doc?: TDocument + filter?: TermVectorFilter + per_field_analyzer?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface TermVectorsResponse { + found?: boolean + _id?: string + _index?: string + term_vectors?: Record + took?: long + _type?: string + _version?: long + } + + export interface TermVectorsResult { + found?: boolean + id?: string + index?: string + term_vectors?: Record + took?: long + version?: long + } + + export interface Token { + end_offset?: integer + payload?: string + position?: integer + start_offset?: integer + } + + /** + * @description Stability: STABLE + */ + export interface UpdateRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + if_primary_term?: long + if_seq_no?: long + lang?: string + refresh?: Refresh + retry_on_conflict?: long + routing?: Routing + source_enabled?: boolean + timeout?: Time + wait_for_active_shards?: string + _source?: boolean | string | string[] + body?: { + detect_noop?: boolean + doc?: TPartialDocument + doc_as_upsert?: boolean + script?: Script + scripted_upsert?: boolean + _source?: boolean | SourceFilter + upsert?: TDocument + } + } + + /** + * @description Stability: STABLE + */ + export interface UpdateResponse extends WriteResponseBase { + get?: InlineGet + } + + export interface IndexState { + aliases?: Record + mappings?: TypeMapping + settings?: Record + } + + export interface Alias { + filter?: QueryContainer + index_routing?: Routing + is_hidden?: boolean + is_write_index?: boolean + routing?: Routing + search_routing?: Routing + } + + export interface AliasDefinition { + filter?: QueryContainer + index_routing?: string + is_write_index?: boolean + routing?: string + search_routing?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface BulkAliasRequest extends RequestBase { + master_timeout?: Time + timeout?: Time + body?: { + actions?: AliasAction[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface BulkAliasResponse extends AcknowledgedResponseBase { + } + + export interface AliasAction { + } + + /** + * @description Stability: UNSTABLE + */ + export interface AliasExistsRequest extends RequestBase { + name: Names + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteAliasRequest extends RequestBase { + index: Indices + name: Names + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteAliasResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAliasRequest extends RequestBase { + name?: Names + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAliasResponse extends Record { + } + + export interface IndexAliases { + aliases?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutAliasRequest extends RequestBase { + index: Indices + name: Name + master_timeout?: Time + timeout?: Time + body?: { + filter?: QueryContainer + index_routing?: Routing + is_write_index?: boolean + routing?: Routing + search_routing?: Routing + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutAliasResponse { + } + + export interface AnalyzeDetail { + charfilters?: CharFilterDetail[] + custom_analyzer?: boolean + tokenfilters?: TokenDetail[] + tokenizer?: TokenDetail + } + + /** + * @description Stability: UNSTABLE + */ + export interface AnalyzeRequest extends RequestBase { + index?: IndexName + body?: { + analyzer?: string + attributes?: string[] + char_filter?: string | ICharFilter[] + explain?: boolean + field?: Field + filter?: string | ITokenFilter[] + normalizer?: string + text?: string[] + tokenizer?: string | ITokenizer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface AnalyzeResponse { + detail?: AnalyzeDetail + tokens?: AnalyzeToken[] + } + + export interface AnalyzeToken { + end_offset?: long + position?: long + position_length?: long + start_offset?: long + token?: string + type?: string + } + + export interface CharFilterDetail { + filtered_text?: string[] + name?: string + } + + export interface ExplainAnalyzeToken { + bytes?: string + end_offset?: long + keyword?: boolean + position?: long + positionLength?: long + start_offset?: long + termFrequency?: long + token?: string + type?: string + } + + export interface TokenDetail { + name?: string + tokens?: ExplainAnalyzeToken[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloneIndexRequest extends RequestBase { + index: IndexName + target: IndexName + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + body?: { + aliases?: Record + settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloneIndexResponse extends AcknowledgedResponseBase { + index?: string + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateIndexRequest extends RequestBase { + index: IndexName + include_type_name?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + body?: { + aliases?: Record + mappings?: TypeMapping + settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateIndexResponse extends AcknowledgedResponseBase { + index?: string + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteIndexRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteIndexResponse extends IndicesResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface FreezeIndexRequest extends RequestBase { + index: IndexName + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface FreezeIndexResponse extends AcknowledgedResponseBase { + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flat_settings?: boolean + ignore_unavailable?: boolean + include_defaults?: boolean + include_type_name?: boolean + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexResponse extends Record { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExistsResponse { + exists?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndexExistsRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flat_settings?: boolean + ignore_unavailable?: boolean + include_defaults?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloseIndexRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloseIndexResponse extends AcknowledgedResponseBase { + indices?: Record + shards_acknowledged?: boolean + } + + export interface CloseIndexResult { + closed?: boolean + shards?: Record + } + + export interface CloseShardResult { + failures?: ShardFailure[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface OpenIndexRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface OpenIndexResponse extends AcknowledgedResponseBase { + } + + export interface RolloverConditions { + max_age?: Time + max_docs?: long + max_size?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface RolloverIndexRequest extends RequestBase { + alias: Name + new_index?: IndexName + dry_run?: boolean + include_type_name?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + body?: { + aliases?: Record + conditions?: RolloverConditions + mappings?: TypeMapping + settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RolloverIndexResponse extends AcknowledgedResponseBase { + conditions?: Record + dry_run?: boolean + new_index?: string + old_index?: string + rolled_over?: boolean + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ShrinkIndexRequest extends RequestBase { + index: IndexName + target: IndexName + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + body?: { + aliases?: Record + settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ShrinkIndexResponse extends AcknowledgedResponseBase { + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface SplitIndexRequest extends RequestBase { + index: IndexName + target: IndexName + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + body?: { + aliases?: Record + settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface SplitIndexResponse extends AcknowledgedResponseBase { + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface TypeExistsRequest extends RequestBase { + index: Indices + type: Types + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface UnfreezeIndexRequest extends RequestBase { + index: IndexName + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time + wait_for_active_shards?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface UnfreezeIndexResponse extends AcknowledgedResponseBase { + shards_acknowledged?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexSettingsRequest extends RequestBase { + index?: Indices + name?: Names + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flat_settings?: boolean + ignore_unavailable?: boolean + include_defaults?: boolean + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexSettingsResponse extends Record { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteIndexTemplateRequest extends RequestBase { + name: Name + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteIndexTemplateResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexTemplateRequest extends RequestBase { + name?: Names + flat_settings?: boolean + include_type_name?: boolean + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIndexTemplateResponse extends Record { + } + + export interface TemplateMapping { + aliases?: Record + index_patterns?: string[] + mappings?: TypeMapping + order?: integer + settings?: Record + version?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndexTemplateExistsRequest extends RequestBase { + name: Names + flat_settings?: boolean + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutIndexTemplateRequest extends RequestBase { + name: Name + create?: boolean + flat_settings?: boolean + include_type_name?: boolean + master_timeout?: Time + timeout?: Time + body?: { + aliases?: Record + index_patterns?: string[] + mappings?: TypeMapping + order?: integer + settings?: Record + version?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutIndexTemplateResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateIndexSettingsRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flat_settings?: boolean + ignore_unavailable?: boolean + master_timeout?: Time + preserve_existing?: boolean + timeout?: Time + body?: { + index_settings?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateIndexSettingsResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetFieldMappingRequest extends RequestBase { + fields: Fields + index?: Indices + type?: Types + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + include_defaults?: boolean + include_type_name?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetFieldMappingResponse extends Record { + } + + export interface TypeFieldMappings { + mappings?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetMappingRequest extends RequestBase { + index?: Indices + type?: Types + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + include_type_name?: boolean + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetMappingResponse extends Record { + } + + export interface IndexMappings { + item?: TypeMapping + mappings?: TypeMapping + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutMappingRequest extends RequestBase { + index?: Indices + type?: TypeName + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + include_type_name?: boolean + master_timeout?: Time + timeout?: Time + body?: { + all_field?: AllField + date_detection?: boolean + dynamic?: boolean | DynamicMapping + dynamic_date_formats?: string[] + dynamic_templates?: Record + field_names_field?: FieldNamesField + index_field?: IndexField + meta?: Record + numeric_detection?: boolean + properties?: Record + routing_field?: RoutingField + size_field?: SizeField + source_field?: SourceField + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutMappingResponse extends IndicesResponseBase { + } + + export interface RecoveryBytes { + percent?: string + recovered?: long + reused?: long + total?: long + } + + export interface RecoveryFileDetails { + length?: long + name?: string + recovered?: long + } + + export interface RecoveryFiles { + details?: RecoveryFileDetails[] + percent?: string + recovered?: long + reused?: long + total?: long + } + + export interface RecoveryIndexStatus { + bytes?: RecoveryBytes + files?: RecoveryFiles + size?: RecoveryBytes + source_throttle_time_in_millis?: long + target_throttle_time_in_millis?: long + total_time_in_millis?: long + } + + export interface RecoveryOrigin { + hostname?: string + id?: string + ip?: string + name?: string + } + + export interface RecoveryStartStatus { + check_index_time?: long + total_time_in_millis?: string + } + + export interface RecoveryStatus { + shards?: ShardRecovery[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface RecoveryStatusRequest extends RequestBase { + index?: Indices + active_only?: boolean + detailed?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface RecoveryStatusResponse extends Record { + } + + export interface RecoveryTranslogStatus { + percent?: string + recovered?: long + total?: long + total_on_start?: long + total_time?: string + total_time_in_millis?: long + } + + export interface RecoveryVerifyIndex { + check_index_time_in_millis?: long + total_time_in_millis?: long + } + + export interface ShardRecovery { + id?: long + index?: RecoveryIndexStatus + primary?: boolean + source?: RecoveryOrigin + stage?: string + start?: RecoveryStartStatus + start_time_in_millis?: Date + stop_time_in_millis?: Date + target?: RecoveryOrigin + total_time_in_millis?: long + translog?: RecoveryTranslogStatus + type?: string + verify_index?: RecoveryVerifyIndex + } + + export interface IndexSegment { + shards?: Record + } + + export interface Segment { + attributes?: Record + committed?: boolean + compound?: boolean + deleted_docs?: long + generation?: integer + memory_in_bytes?: double + search?: boolean + size_in_bytes?: double + num_docs?: long + version?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface SegmentsRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface SegmentsResponse { + indices?: Record + _shards?: ShardStatistics + } + + export interface ShardSegmentRouting { + node?: string + primary?: boolean + state?: string + } + + export interface ShardsSegment { + num_committed_segments?: integer + routing?: ShardSegmentRouting + num_search_segments?: integer + segments?: Record + } + + export interface IndicesShardStores { + shards?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndicesShardStoresRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + status?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndicesShardStoresResponse { + indices?: Record + } + + export interface ShardStore { + allocation?: ShardStoreAllocation + allocation_id?: string + attributes?: Record + id?: string + legacy_version?: long + name?: string + store_exception?: ShardStoreException + transport_address?: string + } + + export interface ShardStoreException { + reason?: string + type?: string + } + + export interface ShardStoreWrapper { + stores?: ShardStore[] + } + + export interface IndexStats { + completion?: CompletionStats + docs?: DocStats + fielddata?: FielddataStats + flush?: FlushStats + get?: GetStats + indexing?: IndexingStats + merges?: MergesStats + query_cache?: QueryCacheStats + recovery?: RecoveryStats + refresh?: RefreshStats + request_cache?: RequestCacheStats + search?: SearchStats + segments?: SegmentsStats + store?: StoreStats + translog?: TranslogStats + warmer?: WarmerStats + } + + export interface IndicesStats { + primaries?: IndexStats + shards?: Record + total?: IndexStats + uuid?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndicesStatsRequest extends RequestBase { + metric?: Metrics + index?: Indices + completion_fields?: Field[] + expand_wildcards?: ExpandWildcards + fielddata_fields?: Field[] + fields?: Field[] + forbid_closed_indices?: boolean + groups?: string[] + include_segment_file_sizes?: boolean + include_unloaded_segments?: boolean + level?: Level + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndicesStatsResponse { + indices?: Record + _shards?: ShardStatistics + _all?: IndicesStats + } + + export interface ShardCommit { + generation?: integer + id?: string + num_docs?: long + user_data?: Record + } + + export interface ShardCompletion { + size_in_bytes?: long + } + + export interface ShardDocs { + count?: long + deleted?: long + } + + export interface ShardFielddata { + evictions?: long + memory_size_in_bytes?: long + } + + export interface ShardFileSizeInfo { + description?: string + size_in_bytes?: long + } + + export interface ShardFlush { + total?: long + total_time_in_millis?: long + } + + export interface ShardGet { + current?: long + exists_time_in_millis?: long + exists_total?: long + missing_time_in_millis?: long + missing_total?: long + time_in_millis?: long + total?: long + } + + export interface ShardIndexing { + delete_current?: long + delete_time_in_millis?: long + delete_total?: long + index_current?: long + index_failed?: long + index_time_in_millis?: long + index_total?: long + is_throttled?: boolean + noop_update_total?: long + throttle_time_in_millis?: long + } + + export interface ShardMerges { + current?: long + current_docs?: long + current_size_in_bytes?: long + total?: long + total_auto_throttle_in_bytes?: long + total_docs?: long + total_size_in_bytes?: long + total_stopped_time_in_millis?: long + total_throttled_time_in_millis?: long + total_time_in_millis?: long + } + + export interface ShardPath { + data_path?: string + is_custom_data_path?: boolean + state_path?: string + } + + export interface ShardQueryCache { + cache_count?: long + cache_size?: long + evictions?: long + hit_count?: long + memory_size_in_bytes?: long + miss_count?: long + total_count?: long + } + + export interface ShardRefresh { + listeners?: long + total?: long + total_time_in_millis?: long + } + + export interface ShardRequestCache { + evictions?: long + hit_count?: long + memory_size_in_bytes?: long + miss_count?: long + } + + export interface ShardRouting { + node?: string + primary?: boolean + relocating_node?: string + state?: ShardRoutingState + } + + export interface ShardSearch { + fetch_current?: long + fetch_time_in_millis?: long + fetch_total?: long + open_contexts?: long + query_current?: long + query_time_in_millis?: long + query_total?: long + scroll_current?: long + scroll_time_in_millis?: long + scroll_total?: long + suggest_current?: long + suggest_time_in_millis?: long + suggest_total?: long + } + + export interface ShardSegments { + count?: long + doc_values_memory_in_bytes?: long + file_sizes?: Record + fixed_bit_set_memory_in_bytes?: long + index_writer_memory_in_bytes?: long + max_unsafe_auto_id_timestamp?: long + memory_in_bytes?: long + norms_memory_in_bytes?: long + points_memory_in_bytes?: long + stored_fields_memory_in_bytes?: long + terms_memory_in_bytes?: long + term_vectors_memory_in_bytes?: long + version_map_memory_in_bytes?: long + } + + export interface ShardSequenceNumber { + global_checkpoint?: long + local_checkpoint?: long + max_seq_no?: long + } + + export interface ShardStats { + commit?: ShardCommit + completion?: ShardCompletion + docs?: ShardDocs + fielddata?: ShardFielddata + flush?: ShardFlush + get?: ShardGet + indexing?: ShardIndexing + merges?: ShardMerges + shard_path?: ShardPath + query_cache?: ShardQueryCache + recovery?: ShardStatsRecovery + refresh?: ShardRefresh + request_cache?: ShardRequestCache + routing?: ShardRouting + search?: ShardSearch + segments?: ShardSegments + seq_no?: ShardSequenceNumber + store?: ShardStatsStore + translog?: ShardTransactionLog + warmer?: ShardWarmer + } + + export interface ShardStatsRecovery { + current_as_source?: long + current_as_target?: long + throttle_time_in_millis?: long + } + + export interface ShardStatsStore { + size_in_bytes?: long + } + + export interface ShardTransactionLog { + operations?: long + size_in_bytes?: long + uncommitted_operations?: long + uncommitted_size_in_bytes?: long + } + + export interface ShardWarmer { + current?: long + total?: long + total_time_in_millis?: long + } + + export interface ReloadDetails { + index?: string + reloaded_analyzers?: string[] + reloaded_node_ids?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReloadSearchAnalyzersRequest extends RequestBase { + index: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ReloadSearchAnalyzersResponse { + reload_details?: ReloadDetails[] + _shards?: ShardStatistics + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCacheRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + fielddata?: boolean + fields?: Field[] + ignore_unavailable?: boolean + query?: boolean + request?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCacheResponse extends ShardsOperationResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface FlushRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + force?: boolean + ignore_unavailable?: boolean + wait_if_ongoing?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface FlushResponse extends ShardsOperationResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForceMergeRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + flush?: boolean + ignore_unavailable?: boolean + max_num_segments?: long + only_expunge_deletes?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForceMergeResponse extends ShardsOperationResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface RefreshRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface RefreshResponse extends ShardsOperationResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface SyncedFlushRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface SyncedFlushResponse extends ShardsOperationResponseBase { + } + + export interface Pipeline { + description?: string + on_failure?: ProcessorContainer[] + processors?: ProcessorContainer[] + } + + export interface ProcessorBase { + if?: string + ignore_failure?: boolean + on_failure?: ProcessorContainer[] + tag?: string + } + + export interface ProcessorContainer { + attachment?: AttachmentProcessor + append?: AppendProcessor + csv?: CsvProcessor + convert?: ConvertProcessor + date?: DateProcessor + date_index_name?: DateIndexNameProcessor + dot_expander?: DotExpanderProcessor + enrich?: EnrichProcessor + fail?: FailProcessor + foreach?: ForeachProcessor + json?: JsonProcessor + user_agent?: UserAgentProcessor + kv?: KeyValueProcessor + geoip?: GeoIpProcessor + grok?: GrokProcessor + gsub?: GsubProcessor + join?: JoinProcessor + lowercase?: LowercaseProcessor + remove?: RemoveProcessor + rename?: RenameProcessor + script?: ScriptProcessor + set?: SetProcessor + sort?: SortProcessor + split?: SplitProcessor + trim?: TrimProcessor + uppercase?: UppercaseProcessor + urldecode?: UrlDecodeProcessor + bytes?: BytesProcessor + dissect?: DissectProcessor + set_security_user?: SetSecurityUserProcessor + pipeline?: PipelineProcessor + drop?: DropProcessor + circle?: CircleProcessor + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeletePipelineRequest extends RequestBase { + id: Id + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeletePipelineResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetPipelineRequest extends RequestBase { + id?: Id + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetPipelineResponse extends Record { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GrokProcessorPatternsRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GrokProcessorPatternsResponse { + patterns?: Record + } + + export interface AppendProcessor extends ProcessorBase { + field?: Field + value?: object[] + } + + export interface BytesProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface CircleProcessor extends ProcessorBase { + error_distance?: double + field?: Field + ignore_missing?: boolean + shape_type?: ShapeType + target_field?: Field + } + + export interface ConvertProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + type?: ConvertProcessorType + } + + export interface CsvProcessor extends ProcessorBase { + empty_value?: object + field?: Field + ignore_missing?: boolean + quote?: string + separator?: string + target_fields?: Field[] + trim?: boolean + } + + export interface DateIndexNameProcessor extends ProcessorBase { + date_formats?: string[] + date_rounding?: DateRounding + field?: Field + index_name_format?: string + index_name_prefix?: string + locale?: string + timezone?: string + } + + export interface DateProcessor extends ProcessorBase { + field?: Field + formats?: string[] + locale?: string + target_field?: Field + timezone?: string + } + + export interface DissectProcessor extends ProcessorBase { + append_separator?: string + field?: Field + ignore_missing?: boolean + pattern?: string + } + + export interface DotExpanderProcessor extends ProcessorBase { + field?: Field + path?: string + } + + export interface DropProcessor extends ProcessorBase { + } + + export interface EnrichProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + max_matches?: integer + override?: boolean + policy_name?: string + shape_relation?: GeoShapeRelation + target_field?: Field + } + + export interface FailProcessor extends ProcessorBase { + message?: string + } + + export interface ForeachProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + processor?: ProcessorContainer + } + + export interface GrokProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + pattern_definitions?: Record + patterns?: string[] + trace_match?: boolean + } + + export interface GsubProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + pattern?: string + replacement?: string + target_field?: Field + } + + export interface JoinProcessor extends ProcessorBase { + field?: Field + separator?: string + target_field?: Field + } + + export interface JsonProcessor extends ProcessorBase { + add_to_root?: boolean + field?: Field + target_field?: Field + } + + export interface KeyValueProcessor extends ProcessorBase { + exclude_keys?: string[] + field?: Field + field_split?: string + ignore_missing?: boolean + include_keys?: string[] + prefix?: string + strip_brackets?: boolean + target_field?: Field + trim_key?: string + trim_value?: string + value_split?: string + } + + export interface LowercaseProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface PipelineProcessor extends ProcessorBase { + name?: string + } + + export interface RemoveProcessor extends ProcessorBase { + field?: Field[] + ignore_missing?: boolean + } + + export interface RenameProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface ScriptProcessor extends ProcessorBase { + id?: string + lang?: string + params?: Record + source?: string + } + + export interface SetProcessor extends ProcessorBase { + field?: Field + override?: boolean + value?: object + } + + export interface SetSecurityUserProcessor extends ProcessorBase { + field?: Field + properties?: string[] + } + + export interface SortProcessor extends ProcessorBase { + field?: Field + order?: SortOrder + target_field?: Field + } + + export interface SplitProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + preserve_trailing?: boolean + separator?: string + target_field?: Field + } + + export interface TrimProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface UppercaseProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface UrlDecodeProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + target_field?: Field + } + + export interface AttachmentProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + indexed_chars?: long + indexed_chars_field?: Field + properties?: string[] + target_field?: Field + } + + export interface GeoIpProcessor extends ProcessorBase { + database_file?: string + field?: Field + first_only?: boolean + ignore_missing?: boolean + properties?: string[] + target_field?: Field + } + + export interface UserAgentProcessor extends ProcessorBase { + field?: Field + ignore_missing?: boolean + options?: UserAgentProperty[] + regex_file?: string + target_field?: Field + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutPipelineRequest extends RequestBase { + id: Id + master_timeout?: Time + timeout?: Time + body?: { + description?: string + on_failure?: ProcessorContainer[] + processors?: ProcessorContainer[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutPipelineResponse extends AcknowledgedResponseBase { + } + + export interface DocumentSimulation { + _id?: string + _index?: string + _ingest?: Ingest + _parent?: string + _routing?: string + _source?: LazyDocument + _type?: string + } + + export interface Ingest { + timestamp?: Date + } + + export interface PipelineSimulation { + doc?: DocumentSimulation + processor_results?: PipelineSimulation[] + tag?: string + } + + export interface SimulatePipelineDocument { + _id?: Id + _index?: IndexName + _source?: object + } + + /** + * @description Stability: UNSTABLE + */ + export interface SimulatePipelineRequest extends RequestBase { + id?: Id + verbose?: boolean + body?: { + docs?: SimulatePipelineDocument[] + pipeline?: Pipeline + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface SimulatePipelineResponse { + docs?: PipelineSimulation[] + } + + export interface TypeMapping { + all_field?: AllField + date_detection?: boolean + dynamic?: boolean | DynamicMapping + dynamic_date_formats?: string[] + dynamic_templates?: Record + _field_names?: FieldNamesField + index_field?: IndexField + _meta?: Record + numeric_detection?: boolean + properties?: Record + _routing?: RoutingField + _size?: SizeField + _source?: SourceField + } + + export interface DynamicTemplate { + mapping?: IProperty + match?: string + match_mapping_type?: string + match_pattern?: MatchType + path_match?: string + path_unmatch?: string + unmatch?: string + } + + export interface FieldMapping { + } + + export interface AllField { + analyzer?: string + enabled?: boolean + omit_norms?: boolean + search_analyzer?: string + similarity?: string + store?: boolean + store_term_vector_offsets?: boolean + store_term_vector_payloads?: boolean + store_term_vector_positions?: boolean + store_term_vectors?: boolean + } + + export interface FieldNamesField { + enabled?: boolean + } + + export interface IndexField { + enabled?: boolean + } + + export interface RoutingField { + required?: boolean + } + + export interface SizeField { + enabled?: boolean + } + + export interface SourceField { + compress?: boolean + compress_threshold?: string + enabled?: boolean + excludes?: string[] + includes?: string[] + } + + export interface CorePropertyBase extends PropertyBase { + copy_to?: Field[] + fields?: Record + similarity?: string + store?: boolean + } + + export interface DocValuesPropertyBase extends CorePropertyBase { + doc_values?: boolean + } + + export interface IProperty { + local_metadata?: Record + meta?: Record + name?: PropertyName + type?: string + } + + export interface PropertyBase extends IProperty { + local_metadata?: Record + meta?: Record + name?: PropertyName + type?: string + } + + export interface PropertyWithClrOrigin { + } + + export interface FlattenedProperty extends PropertyBase { + boost?: double + depth_limit?: integer + doc_values?: boolean + eager_global_ordinals?: boolean + ignore_above?: integer + index?: boolean + index_options?: IndexOptions + null_value?: string + similarity?: string + split_queries_on_whitespace?: boolean + } + + export interface NestedProperty extends ObjectProperty { + include_in_parent?: boolean + include_in_root?: boolean + } + + export interface ObjectProperty extends CorePropertyBase { + dynamic?: boolean | DynamicMapping + enabled?: boolean + properties?: Record + } + + export interface BinaryProperty extends DocValuesPropertyBase { + } + + export interface BooleanProperty extends DocValuesPropertyBase { + boost?: double + fielddata?: NumericFielddata + index?: boolean + null_value?: boolean + } + + export interface DateProperty extends DocValuesPropertyBase { + boost?: double + fielddata?: NumericFielddata + format?: string + ignore_malformed?: boolean + index?: boolean + null_value?: Date + precision_step?: integer + } + + export interface DateNanosProperty extends DocValuesPropertyBase { + boost?: double + format?: string + ignore_malformed?: boolean + index?: boolean + null_value?: Date + precision_step?: integer + } + + export interface JoinProperty extends PropertyBase { + relations?: Record + } + + export interface KeywordProperty extends DocValuesPropertyBase { + boost?: double + eager_global_ordinals?: boolean + ignore_above?: integer + index?: boolean + index_options?: IndexOptions + normalizer?: string + norms?: boolean + null_value?: string + split_queries_on_whitespace?: boolean + } + + export interface NumberProperty extends DocValuesPropertyBase { + boost?: double + coerce?: boolean + fielddata?: NumericFielddata + ignore_malformed?: boolean + index?: boolean + null_value?: double + scaling_factor?: double + } + + export interface PercolatorProperty extends PropertyBase { + } + + export interface RangePropertyBase extends DocValuesPropertyBase { + boost?: double + coerce?: boolean + index?: boolean + } + + export interface DateRangeProperty extends RangePropertyBase { + format?: string + } + + export interface DoubleRangeProperty extends RangePropertyBase { + } + + export interface FloatRangeProperty extends RangePropertyBase { + } + + export interface IntegerRangeProperty extends RangePropertyBase { + } + + export interface IpRangeProperty extends RangePropertyBase { + } + + export interface LongRangeProperty extends RangePropertyBase { + } + + export interface RankFeatureProperty extends PropertyBase { + positive_score_impact?: boolean + } + + export interface RankFeaturesProperty extends PropertyBase { + } + + export interface SearchAsYouTypeProperty extends CorePropertyBase { + analyzer?: string + index?: boolean + index_options?: IndexOptions + max_shingle_size?: integer + norms?: boolean + search_analyzer?: string + search_quote_analyzer?: string + term_vector?: TermVectorOption + } + + export interface TextIndexPrefixes { + max_chars?: integer + min_chars?: integer + } + + export interface TextProperty extends CorePropertyBase { + analyzer?: string + boost?: double + eager_global_ordinals?: boolean + fielddata?: boolean + fielddata_frequency_filter?: FielddataFrequencyFilter + index?: boolean + index_options?: IndexOptions + index_phrases?: boolean + index_prefixes?: TextIndexPrefixes + norms?: boolean + position_increment_gap?: integer + search_analyzer?: string + search_quote_analyzer?: string + term_vector?: TermVectorOption + } + + export interface GeoPointProperty extends DocValuesPropertyBase { + ignore_malformed?: boolean + ignore_z_value?: boolean + null_value?: GeoLocation + } + + export interface GeoShapeProperty extends DocValuesPropertyBase { + coerce?: boolean + ignore_malformed?: boolean + ignore_z_value?: boolean + orientation?: GeoOrientation + strategy?: GeoStrategy + } + + export interface CompletionProperty extends DocValuesPropertyBase { + analyzer?: string + contexts?: SuggestContext[] + max_input_length?: integer + preserve_position_increments?: boolean + preserve_separators?: boolean + search_analyzer?: string + } + + export interface SuggestContext { + name?: string + path?: Field + type?: string + } + + export interface ConstantKeywordProperty extends PropertyBase { + value?: object + } + + export interface FieldAliasProperty extends PropertyBase { + path?: Field + } + + export interface GenericProperty extends DocValuesPropertyBase { + analyzer?: string + boost?: double + fielddata?: StringFielddata + ignore_above?: integer + index?: boolean + index_options?: IndexOptions + norms?: boolean + null_value?: string + position_increment_gap?: integer + search_analyzer?: string + term_vector?: TermVectorOption + type?: string + } + + export interface HistogramProperty extends PropertyBase { + ignore_malformed?: boolean + } + + export interface IpProperty extends DocValuesPropertyBase { + boost?: double + index?: boolean + null_value?: string + } + + export interface Murmur3HashProperty extends DocValuesPropertyBase { + } + + export interface ShapeProperty extends DocValuesPropertyBase { + coerce?: boolean + ignore_malformed?: boolean + ignore_z_value?: boolean + orientation?: ShapeOrientation + } + + export interface TokenCountProperty extends DocValuesPropertyBase { + analyzer?: string + boost?: double + index?: boolean + null_value?: double + } + + export interface IndicesModuleSettings { + circuit_breaker_settings?: CircuitBreakerSettings + fielddata_settings?: FielddataSettings + qeueries_cache_size?: string + recovery_settings?: IndicesRecoverySettings + } + + export interface CircuitBreakerSettings { + fielddata_limit?: string + fielddata_overhead?: float + request_limit?: string + request_overhead?: float + total_limit?: string + } + + export interface Fielddata { + filter?: FielddataFilter + loading?: FielddataLoading + } + + export interface FielddataFilter { + frequency?: FielddataFrequencyFilter + regex?: FielddataRegexFilter + } + + export interface FielddataFrequencyFilter { + max?: double + min?: double + min_segment_size?: integer + } + + export interface FielddataRegexFilter { + pattern?: string + } + + export interface FielddataSettings { + cache_expire?: Time + cache_size?: string + } + + export interface NumericFielddata { + format?: NumericFielddataFormat + } + + export interface StringFielddata { + format?: StringFielddataFormat + } + + export interface IndicesRecoverySettings { + compress?: boolean + concurrent_small_file_streams?: integer + concurrent_streams?: integer + file_chunk_size?: string + max_bytes_per_second?: string + translog_operations?: integer + translog_size?: string + } + + export interface StoredScript { + lang?: string + source?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteScriptRequest extends RequestBase { + id: Id + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteScriptResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecutePainlessScriptRequest extends RequestBase { + body?: { + context?: string + context_setup?: PainlessContextSetup + script?: InlineScript + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecutePainlessScriptResponse { + result?: TResult + } + + export interface PainlessContextSetup { + document?: object + index?: IndexName + query?: QueryContainer + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetScriptRequest extends RequestBase { + id: Id + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetScriptResponse { + script?: StoredScript + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutScriptRequest extends RequestBase { + id: Id + context?: Name + master_timeout?: Time + timeout?: Time + body?: { + script?: StoredScript + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutScriptResponse extends AcknowledgedResponseBase { + } + + export interface SnapshotRepository { + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface CleanupRepositoryRequest extends RequestBase { + repository: Name + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface CleanupRepositoryResponse { + results?: CleanupRepositoryResults + } + + export interface CleanupRepositoryResults { + deleted_blobs?: long + deleted_bytes?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateRepositoryRequest extends RequestBase { + repository: Name + master_timeout?: Time + timeout?: Time + verify?: boolean + body?: { + repository?: SnapshotRepository + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateRepositoryResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRepositoryRequest extends RequestBase { + repository: Names + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRepositoryResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRepositoryRequest extends RequestBase { + repository?: Names + local?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRepositoryResponse { + repositories?: Record + } + + export interface CompactNodeInfo { + name?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface VerifyRepositoryRequest extends RequestBase { + repository: Name + master_timeout?: Time + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface VerifyRepositoryResponse { + nodes?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface RestoreRequest extends RequestBase { + repository: Name + snapshot: Name + master_timeout?: Time + wait_for_completion?: boolean + body?: { + ignore_index_settings?: string[] + ignore_unavailable?: boolean + include_aliases?: boolean + include_global_state?: boolean + index_settings?: UpdateIndexSettingsRequest + indices?: Indices + partial?: boolean + rename_pattern?: string + rename_replacement?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RestoreResponse { + snapshot?: SnapshotRestore + } + + export interface SnapshotRestore { + indices?: IndexName[] + snapshot?: string + shards?: ShardStatistics + } + + export interface SnapshotInfo { + duration_in_millis?: long + end_time?: Date + end_time_in_millis?: long + failures?: SnapshotShardFailure[] + indices?: IndexName[] + metadata?: Record + snapshot?: string + shards?: ShardStatistics + start_time?: Date + start_time_in_millis?: long + state?: string + } + + export interface SnapshotShardFailure { + index?: string + node_id?: string + reason?: string + shard_id?: string + status?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteSnapshotRequest extends RequestBase { + repository: Name + snapshot: Name + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteSnapshotResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotRequest extends RequestBase { + repository: Name + snapshot: Names + ignore_unavailable?: boolean + master_timeout?: Time + verbose?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotResponse { + snapshots?: SnapshotInfo[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface SnapshotRequest extends RequestBase { + repository: Name + snapshot: Name + master_timeout?: Time + wait_for_completion?: boolean + body?: { + ignore_unavailable?: boolean + include_global_state?: boolean + indices?: Indices + metadata?: Record + partial?: boolean + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface SnapshotResponse { + accepted?: boolean + snapshot?: SnapshotInfo + } + + export interface FileCountSnapshotStats { + file_count?: integer + size_in_bytes?: long + } + + export interface SnapshotIndexStats { + shards?: Record + shards_stats?: SnapshotShardsStats + stats?: SnapshotStats + } + + export interface SnapshotShardsStats { + done?: long + failed?: long + finalizing?: long + initializing?: long + started?: long + total?: long + } + + export interface SnapshotStats { + incremental?: FileCountSnapshotStats + start_time_in_millis?: long + time_in_millis?: long + total?: FileCountSnapshotStats + } + + export interface SnapshotStatus { + include_global_state?: boolean + indices?: Record + repository?: string + shards_stats?: SnapshotShardsStats + snapshot?: string + state?: string + stats?: SnapshotStats + uuid?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface SnapshotStatusRequest extends RequestBase { + repository?: Name + snapshot?: Names + ignore_unavailable?: boolean + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface SnapshotStatusResponse { + snapshots?: SnapshotStatus[] + } + + export interface MatchAllQuery { + norm_field?: string + } + + export interface MatchNoneQuery { + } + + export interface QueryContainer { + bool?: BoolQuery + boosting?: BoostingQuery + common?: Record + constant_score?: ConstantScoreQuery + dis_max?: DisMaxQuery + distance_feature?: Record + exists?: ExistsQuery + function_score?: FunctionScoreQuery + fuzzy?: Record + geo_bounding_box?: Record + geo_distance?: Record + geo_polygon?: Record + geo_shape?: Record + has_child?: HasChildQuery + has_parent?: HasParentQuery + ids?: IdsQuery + intervals?: Record + is_conditionless?: boolean + is_strict?: boolean + is_verbatim?: boolean + is_writable?: boolean + match?: Record + match_all?: MatchAllQuery + match_bool_prefix?: Record + match_none?: MatchNoneQuery + match_phrase?: Record + match_phrase_prefix?: Record + more_like_this?: MoreLikeThisQuery + multi_match?: MultiMatchQuery + nested?: NestedQuery + parent_id?: ParentIdQuery + percolate?: PercolateQuery + pinned?: PinnedQuery + prefix?: Record + query_string?: QueryStringQuery + range?: RangeQuery + rank_feature?: Record + raw_query?: RawQuery + regexp?: Record + script?: ScriptQuery + script_score?: ScriptScoreQuery + shape?: Record + simple_query_string?: SimpleQueryStringQuery + span_containing?: SpanContainingQuery + field_masking_span?: SpanFieldMaskingQuery + span_first?: SpanFirstQuery + span_multi?: SpanMultiTermQuery + span_near?: SpanNearQuery + span_not?: SpanNotQuery + span_or?: SpanOrQuery + span_term?: Record + span_within?: SpanWithinQuery + term?: Record + terms?: Record + terms_set?: Record + wildcard?: Record + } + + export interface FieldLookup { + id?: Id + index?: IndexName + path?: Field + routing?: Routing + } + + export interface FieldNameQuery { + field?: Field + } + + export interface Query { + boost?: double + conditionless?: boolean + is_strict?: boolean + is_verbatim?: boolean + is_writable?: boolean + _name?: string + } + + export interface BoolQuery { + filter?: QueryContainer[] + locked?: boolean + minimum_should_match?: MinimumShouldMatch + must?: QueryContainer[] + must_not?: QueryContainer[] + should?: QueryContainer[] + _name?: string + } + + export interface BoostingQuery { + negative_boost?: double + negative?: QueryContainer + positive?: QueryContainer + } + + export interface ConstantScoreQuery { + filter?: QueryContainer + } + + export interface DisMaxQuery { + queries?: QueryContainer[] + tie_breaker?: double + } + + export interface FunctionScoreQuery { + boost_mode?: FunctionBoostMode + functions?: ScoreFunction[] + max_boost?: double + min_score?: double + query?: QueryContainer + score_mode?: FunctionScoreMode + } + + export interface ScoreFunction { + filter?: QueryContainer + weight?: double + } + + export interface CommonTermsQuery { + analyzer?: string + cutoff_frequency?: double + high_freq_operator?: Operator + low_freq_operator?: Operator + minimum_should_match?: MinimumShouldMatch + query?: string + } + + export interface Intervals { + filter?: IntervalsFilter + } + + export interface IntervalsAllOf { + intervals?: IntervalsContainer[] + max_gaps?: integer + ordered?: boolean + } + + export interface IntervalsAnyOf { + intervals?: IntervalsContainer[] + } + + export interface IntervalsContainer { + all_of?: IntervalsAllOf + any_of?: IntervalsAnyOf + fuzzy?: IntervalsFuzzy + match?: IntervalsMatch + prefix?: IntervalsPrefix + wildcard?: IntervalsWildcard + } + + export interface IntervalsFilter { + after?: IntervalsContainer + before?: IntervalsContainer + contained_by?: IntervalsContainer + containing?: IntervalsContainer + not_contained_by?: IntervalsContainer + not_containing?: IntervalsContainer + not_overlapping?: IntervalsContainer + overlapping?: IntervalsContainer + script?: Script + } + + export interface IntervalsFuzzy { + analyzer?: string + fuzziness?: Fuzziness + prefix_length?: integer + term?: string + transpositions?: boolean + use_field?: Field + } + + export interface IntervalsMatch { + analyzer?: string + max_gaps?: integer + ordered?: boolean + query?: string + use_field?: Field + } + + export interface IntervalsNoFilter { + } + + export interface IntervalsPrefix { + analyzer?: string + prefix?: string + use_field?: Field + } + + export interface IntervalsQuery { + } + + export interface IntervalsWildcard { + analyzer?: string + pattern?: string + use_field?: Field + } + + export interface MatchQuery { + analyzer?: string + auto_generate_synonyms_phrase_query?: boolean + cutoff_frequency?: double + fuzziness?: Fuzziness + fuzzy_rewrite?: MultiTermQueryRewrite + fuzzy_transpositions?: boolean + lenient?: boolean + max_expansions?: integer + minimum_should_match?: MinimumShouldMatch + operator?: Operator + prefix_length?: integer + query?: string + zero_terms_query?: ZeroTermsQuery + } + + export interface MatchBoolPrefixQuery { + analyzer?: string + fuzziness?: Fuzziness + fuzzy_rewrite?: MultiTermQueryRewrite + fuzzy_transpositions?: boolean + max_expansions?: integer + minimum_should_match?: MinimumShouldMatch + operator?: Operator + prefix_length?: integer + query?: string + } + + export interface MatchPhraseQuery { + analyzer?: string + query?: string + slop?: integer + } + + export interface MatchPhrasePrefixQuery { + analyzer?: string + max_expansions?: integer + query?: string + slop?: integer + zero_terms_query?: ZeroTermsQuery + } + + export interface MultiMatchQuery { + analyzer?: string + auto_generate_synonyms_phrase_query?: boolean + cutoff_frequency?: double + fields?: Field[] + fuzziness?: Fuzziness + fuzzy_rewrite?: MultiTermQueryRewrite + fuzzy_transpositions?: boolean + lenient?: boolean + max_expansions?: integer + minimum_should_match?: MinimumShouldMatch + operator?: Operator + prefix_length?: integer + query?: string + slop?: integer + tie_breaker?: double + type?: TextQueryType + use_dis_max?: boolean + zero_terms_query?: ZeroTermsQuery + } + + export interface QueryStringQuery { + allow_leading_wildcard?: boolean + analyzer?: string + analyze_wildcard?: boolean + auto_generate_synonyms_phrase_query?: boolean + default_field?: Field + default_operator?: Operator + enable_position_increments?: boolean + escape?: boolean + fields?: Field[] + fuzziness?: Fuzziness + fuzzy_max_expansions?: integer + fuzzy_prefix_length?: integer + fuzzy_rewrite?: MultiTermQueryRewrite + fuzzy_transpositions?: boolean + lenient?: boolean + max_determinized_states?: integer + minimum_should_match?: MinimumShouldMatch + phrase_slop?: double + query?: string + quote_analyzer?: string + quote_field_suffix?: string + rewrite?: MultiTermQueryRewrite + tie_breaker?: double + time_zone?: string + type?: TextQueryType + } + + export interface SimpleQueryStringQuery { + analyzer?: string + analyze_wildcard?: boolean + auto_generate_synonyms_phrase_query?: boolean + default_operator?: Operator + fields?: Field[] + flags?: SimpleQueryStringFlags + fuzzy_max_expansions?: integer + fuzzy_prefix_length?: integer + fuzzy_transpositions?: boolean + lenient?: boolean + minimum_should_match?: MinimumShouldMatch + query?: string + quote_field_suffix?: string + } + + export interface GeoCoordinate extends GeoLocation { + z?: double + } + + export interface GeoLocation { + lat?: double + lon?: double + } + + export interface BoundingBox { + bottom_right?: GeoLocation + top_left?: GeoLocation + wkt?: string + } + + export interface GeoBoundingBoxQuery { + bounding_box?: BoundingBox + type?: GeoExecution + validation_method?: GeoValidationMethod + } + + export interface GeoDistanceQuery { + distance?: Distance + distance_type?: GeoDistanceType + location?: GeoLocation + validation_method?: GeoValidationMethod + } + + export interface GeoPolygonQuery { + points?: GeoLocation[] + validation_method?: GeoValidationMethod + } + + export interface GeoShape { + type?: string + } + + export interface GeoShapeQuery { + ignore_unmapped?: boolean + indexed_shape?: FieldLookup + relation?: GeoShapeRelation + shape?: GeoShape + } + + export interface HasChildQuery { + ignore_unmapped?: boolean + inner_hits?: InnerHits + max_children?: integer + min_children?: integer + query?: QueryContainer + score_mode?: ChildScoreMode + type?: RelationName + } + + export interface HasParentQuery { + ignore_unmapped?: boolean + inner_hits?: InnerHits + parent_type?: RelationName + query?: QueryContainer + score?: boolean + } + + export interface NestedQuery { + ignore_unmapped?: boolean + inner_hits?: InnerHits + path?: Field + query?: QueryContainer + score_mode?: NestedScoreMode + } + + export interface ParentIdQuery { + id?: Id + ignore_unmapped?: boolean + type?: RelationName + } + + export interface MultiTermQueryRewrite { + constant_score?: MultiTermQueryRewrite + constant_score_boolean?: MultiTermQueryRewrite + rewrite?: RewriteMultiTerm + scoring_boolean?: MultiTermQueryRewrite + size?: integer + } + + export interface RawQuery { + raw?: string + } + + export interface SpanQuery { + span_containing?: SpanContainingQuery + field_masking_span?: SpanFieldMaskingQuery + span_first?: SpanFirstQuery + span_gap?: SpanGapQuery + span_multi?: SpanMultiTermQuery + span_near?: SpanNearQuery + span_not?: SpanNotQuery + span_or?: SpanOrQuery + span_term?: SpanTermQuery + span_within?: SpanWithinQuery + } + + export interface SpanSubQuery { + } + + export interface SpanContainingQuery { + big?: SpanQuery + little?: SpanQuery + } + + export interface SpanFieldMaskingQuery { + field?: Field + query?: SpanQuery + } + + export interface SpanFirstQuery { + end?: integer + match?: SpanQuery + } + + export interface SpanGapQuery { + field?: Field + width?: integer + } + + export interface SpanMultiTermQuery { + match?: QueryContainer + } + + export interface SpanNearQuery { + clauses?: SpanQuery[] + in_order?: boolean + slop?: integer + } + + export interface SpanNotQuery { + dist?: integer + exclude?: SpanQuery + include?: SpanQuery + post?: integer + pre?: integer + } + + export interface SpanOrQuery { + clauses?: SpanQuery[] + } + + export interface SpanTermQuery { + } + + export interface SpanWithinQuery { + big?: SpanQuery + little?: SpanQuery + } + + export interface DistanceFeatureQuery { + origin?: GeoCoordinate | DateMath + pivot?: Distance | Time + } + + export interface MoreLikeThisQuery { + analyzer?: string + boost_terms?: double + fields?: Field[] + include?: boolean + like?: Like[] + max_doc_freq?: integer + max_query_terms?: integer + max_word_length?: integer + min_doc_freq?: integer + minimum_should_match?: MinimumShouldMatch + min_term_freq?: integer + min_word_length?: integer + per_field_analyzer?: Record + routing?: Routing + stop_words?: StopWords + unlike?: Like[] + version?: long + version_type?: VersionType + } + + export type Like = string | LikeDocument + + export interface LikeDocument { + doc?: object + fields?: Field[] + _id?: Id + _index?: IndexName + per_field_analyzer?: Record + routing?: Routing + } + + export interface PercolateQuery { + document?: object + documents?: object[] + field?: Field + id?: Id + index?: IndexName + preference?: string + routing?: Routing + version?: long + } + + export interface PinnedQuery { + ids?: Id[] + organic?: QueryContainer + } + + export interface RankFeatureFunction { + } + + export interface RankFeatureQuery { + function?: RankFeatureFunction + } + + export interface ScriptQuery { + script?: Script + } + + export interface ScriptScoreQuery { + query?: QueryContainer + script?: Script + } + + export interface ShapeQuery { + ignore_unmapped?: boolean + indexed_shape?: FieldLookup + relation?: ShapeRelation + shape?: GeoShape + } + + export interface ExistsQuery { + field?: Field + } + + export interface FuzzyQuery { + max_expansions?: integer + prefix_length?: integer + rewrite?: MultiTermQueryRewrite + transpositions?: boolean + boost?: number + } + + export interface IdsQuery { + values?: Id[] + type: string + } + + export interface PrefixQuery { + rewrite?: MultiTermQueryRewrite + boost?: number + } + + export interface RangeQuery { + } + + export interface RegexpQuery { + flags?: string + max_determinized_states?: integer + value?: string + boost?: number + } + + export interface TermQuery { + value?: object, + boost?: number + } + + export interface TermsQuery { + terms?: object[] + terms_lookup?: FieldLookup + } + + export interface TermsSetQuery { + minimum_should_match_field?: Field + minimum_should_match_script?: Script + terms?: object[] + } + + export interface WildcardQuery { + rewrite?: MultiTermQueryRewrite + boost?: number + } + + /** + * @description Stability: UNSTABLE + */ + export interface TypedSearchRequest { + } + + /** + * @description Stability: UNSTABLE + */ + export interface CountRequest extends RequestBase { + index?: Indices + type?: Types + allow_no_indices?: boolean + analyzer?: string + analyze_wildcard?: boolean + default_operator?: DefaultOperator + df?: string + expand_wildcards?: ExpandWildcards + ignore_throttled?: boolean + ignore_unavailable?: boolean + lenient?: boolean + min_score?: double + preference?: string + query_on_query_string?: string + routing?: Routing + terminate_after?: long + body?: { + query?: QueryContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CountResponse { + count?: long + _shards?: ShardStatistics + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExplainRequest extends RequestBase { + id: Id + index: IndexName + type?: TypeName + analyzer?: string + analyze_wildcard?: boolean + default_operator?: DefaultOperator + df?: string + lenient?: boolean + preference?: string + query_on_query_string?: string + routing?: Routing + source_enabled?: boolean + source_excludes?: Field[] + source_includes?: Field[] + stored_fields?: Field[] + body?: { + query?: QueryContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExplainResponse { + explanation?: ExplanationDetail + get?: InlineGet + matched?: boolean + } + + export interface Explanation { + description?: string + details?: ExplanationDetail[] + value?: float + } + + export interface ExplanationDetail { + description?: string + details?: ExplanationDetail[] + value?: float + } + + export interface InlineGet { + fields?: Record + found?: boolean + _seq_no?: long + _primary_term?: long + _source?: TDocument + } + + export interface FieldCapabilities { + aggregatable?: boolean + indices?: Indices + meta?: Record + non_aggregatable_indices?: Indices + non_searchable_indices?: Indices + searchable?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface FieldCapabilitiesRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + fields?: Field[] + ignore_unavailable?: boolean + include_unmapped?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface FieldCapabilitiesResponse { + fields?: Record> + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiSearchRequest extends RequestBase { + index?: Indices + type?: Types + ccs_minimize_roundtrips?: boolean + max_concurrent_searches?: long + max_concurrent_shard_requests?: long + pre_filter_shard_size?: long + search_type?: SearchType + total_hits_as_integer?: boolean + typed_keys?: boolean + body?: { + operations?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiSearchResponse { + responses?: SearchResponse[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface MultiSearchTemplateRequest extends RequestBase { + index?: Indices + type?: Types + ccs_minimize_roundtrips?: boolean + max_concurrent_searches?: long + search_type?: SearchType + total_hits_as_integer?: boolean + typed_keys?: boolean + body?: { + operations?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearScrollRequest extends RequestBase { + scroll_id?: ScrollIds + body?: { + scroll_id?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearScrollResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ScrollRequest extends RequestBase { + scroll_id?: ScrollId + total_hits_as_integer?: boolean + body?: { + scroll?: Time + scroll_id?: string + } + } + + export interface SlicedScroll { + field?: Field + id?: integer + max?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchRequest extends RequestBase { + index?: Indices + type?: Types + allow_no_indices?: boolean + allow_partial_search_results?: boolean + analyzer?: string + analyze_wildcard?: boolean + batched_reduce_size?: long + ccs_minimize_roundtrips?: boolean + default_operator?: DefaultOperator + df?: string + docvalue_fields?: Field[] + expand_wildcards?: ExpandWildcards + ignore_throttled?: boolean + ignore_unavailable?: boolean + lenient?: boolean + max_concurrent_shard_requests?: long + preference?: string + pre_filter_shard_size?: long + query_on_query_string?: string + request_cache?: boolean + routing?: Routing + scroll?: Time + search_type?: SearchType + sequence_number_primary_term?: boolean + stats?: string[] + stored_fields?: Field[] + suggest_field?: Field + suggest_mode?: SuggestMode + suggest_size?: long + suggest_text?: string + total_hits_as_integer?: boolean + track_total_hits?: boolean + typed_keys?: boolean + rest_total_hits_as_int?: boolean + _source_excludes?: Field | Field[] + _source_includes?: Field | Field[] + body?: { + aggs?: Record + collapse?: FieldCollapse + explain?: boolean + from?: integer + highlight?: Highlight + indices_boost?: Record + min_score?: double + post_filter?: QueryContainer + profile?: boolean + query?: QueryContainer + rescore?: Rescore[] + script_fields?: Record + search_after?: object[] + size?: integer + slice?: SlicedScroll + sort?: Array> + _source?: boolean | Field | Field[] | SourceFilter + suggest?: Record + terminate_after?: long + timeout?: string + track_scores?: boolean + version?: boolean + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchResponse { + aggregations?: Record + _clusters?: ClusterStatistics + documents?: TDocument[] + fields?: Record + hits?: HitsMetadata + max_score?: double + num_reduce_phases?: long + profile?: Profile + _scroll_id?: string + _shards?: ShardStatistics + suggest?: SuggestDictionary + terminated_early?: boolean + timed_out?: boolean + took?: long + total?: long + } + + export interface FieldCollapse { + field?: Field + inner_hits?: InnerHits + max_concurrent_group_searches?: integer + } + + export interface Highlight { + boundary_chars?: string + boundary_max_scan?: integer + boundary_scanner?: BoundaryScanner + boundary_scanner_locale?: string + encoder?: HighlighterEncoder + fields?: Record + fragmenter?: HighlighterFragmenter + fragment_offset?: integer + fragment_size?: integer + max_fragment_length?: integer + no_match_size?: integer + number_of_fragments?: integer + order?: HighlighterOrder + post_tags?: string[] + pre_tags?: string[] + require_field_match?: boolean + tags_schema?: HighlighterTagsSchema + } + + export interface HighlightField { + boundary_chars?: string + boundary_max_scan?: integer + boundary_scanner?: BoundaryScanner + boundary_scanner_locale?: string + field?: Field + force_source?: boolean + fragmenter?: HighlighterFragmenter + fragment_offset?: integer + fragment_size?: integer + highlight_query?: QueryContainer + matched_fields?: Field[] + max_fragment_length?: integer + no_match_size?: integer + number_of_fragments?: integer + order?: HighlighterOrder + phrase_limit?: integer + post_tags?: string[] + pre_tags?: string[] + require_field_match?: boolean + tags_schema?: HighlighterTagsSchema + type?: HighlighterType | string + } + + export interface Hit { + _explanation?: Explanation + fields?: Record + highlight?: Record + inner_hits?: Record + matched_queries?: string[] + _nested?: NestedIdentity + _score?: double + sort?: object[] + } + + export interface HitMetadata { + _id?: string + _index?: string + _primary_term?: long + _routing?: string + _seq_no?: long + _source?: TDocument + _type?: string + _version?: long + } + + export interface HitsMetadata { + hits?: Hit[] + max_score?: double + total?: TotalHits + } + + export interface InnerHitsMetadata { + hits?: Hit[] + max_score?: double + total?: TotalHits + } + + export interface InnerHitsResult { + hits?: InnerHitsMetadata + } + + export interface NestedIdentity { + field?: Field + _nested?: NestedIdentity + offset?: integer + } + + export interface TotalHits { + relation?: TotalHitsRelation + value?: long + } + + export interface InnerHits { + collapse?: FieldCollapse + docvalue_fields?: Field[] + explain?: boolean + from?: integer + highlight?: Highlight + ignore_unmapped?: boolean + name?: string + script_fields?: Record + size?: integer + sort?: Array> + _source?: boolean | SourceFilter + version?: boolean + } + + export interface AggregationBreakdown { + build_aggregation?: long + build_aggregation_count?: long + collect?: long + collect_count?: long + initialize?: long + intialize_count?: long + reduce?: long + reduce_count?: long + } + + export interface AggregationProfile { + breakdown?: AggregationBreakdown + description?: string + time_in_nanos?: long + type?: string + } + + export interface Collector { + children?: Collector[] + name?: string + reason?: string + time_in_nanos?: long + } + + export interface Profile { + shards?: ShardProfile[] + } + + export interface QueryBreakdown { + advance?: long + build_scorer?: long + create_weight?: long + match?: long + next_doc?: long + score?: long + } + + export interface QueryProfile { + breakdown?: QueryBreakdown + children?: QueryProfile[] + description?: string + time_in_nanos?: long + type?: string + } + + export interface SearchProfile { + collector?: Collector[] + query?: QueryProfile[] + rewrite_time?: long + } + + export interface ShardProfile { + aggregations?: AggregationProfile[] + id?: string + searches?: SearchProfile[] + } + + export interface Rescore { + query?: RescoreQuery + window_size?: integer + } + + export interface RescoreQuery { + rescore_query?: QueryContainer + query_weight?: double + rescore_query_weight?: double + score_mode?: ScoreMode + } + + export interface NestedSort { + filter?: QueryContainer + max_children?: integer + nested?: NestedSort + path?: Field + } + + export interface Sort { + missing?: object + mode?: SortMode + nested?: NestedSort + numeric_type?: NumericType + order?: SortOrder + } + + export interface SourceFilter { + excludes?: Field | Field[] + includes?: Field | Field[] + } + + export interface SearchNode { + name?: string + transport_address?: string + } + + export interface SearchShard { + index?: string + node?: string + primary?: boolean + relocating_node?: string + shard?: integer + state?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchShardsRequest extends RequestBase { + index?: Indices + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + local?: boolean + preference?: string + routing?: Routing + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchShardsResponse { + nodes?: Record + shards?: SearchShard[][] + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchTemplateRequest extends RequestBase { + index?: Indices + type?: Types + allow_no_indices?: boolean + ccs_minimize_roundtrips?: boolean + expand_wildcards?: ExpandWildcards + explain?: boolean + ignore_throttled?: boolean + ignore_unavailable?: boolean + preference?: string + profile?: boolean + routing?: Routing + scroll?: Time + search_type?: SearchType + total_hits_as_integer?: boolean + typed_keys?: boolean + body?: { + id?: string + params?: Record + source?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RenderSearchTemplateRequest extends RequestBase { + id?: Id + body?: { + file?: string + params?: Record + source?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RenderSearchTemplateResponse { + template_output?: LazyDocument + } + + export interface Suggest { + length?: integer + offset?: integer + options?: SuggestOption[] + text?: string + } + + export interface SuggestBucket { + completion?: CompletionSuggester + phrase?: PhraseSuggester + prefix?: string + regex?: string + term?: TermSuggester + text?: string + } + + export interface SuggestDictionary { + item?: Suggest[] + keys?: string[] + values?: Suggest[][] + } + + export interface SuggestOption { + collate_match?: boolean + contexts?: Record + fields?: Record + freq?: long + highlighted?: string + _id?: string + _index?: IndexName + _score?: double + score?: double + _source?: TDocument + text?: string + } + + export interface Suggester { + analyzer?: string + field?: Field + size?: integer + } + + export interface CompletionSuggester { + contexts?: Record + fuzzy?: SuggestFuzziness + prefix?: string + regex?: string + skip_duplicates?: boolean + } + + export interface SuggestFuzziness { + fuzziness?: Fuzziness + min_length?: integer + prefix_length?: integer + transpositions?: boolean + unicode_aware?: boolean + } + + export type Context = string | GeoLocation + + export interface SuggestContextQuery { + boost?: double + context?: Context + neighbours?: Distance[] | integer[] + precision?: Distance | integer + prefix?: boolean + } + + export interface DirectGenerator { + field?: Field + max_edits?: integer + max_inspections?: float + max_term_freq?: float + min_doc_freq?: float + min_word_length?: integer + post_filter?: string + pre_filter?: string + prefix_length?: integer + size?: integer + suggest_mode?: SuggestMode + } + + export interface PhraseSuggestCollate { + params?: Record + prune?: boolean + query?: PhraseSuggestCollateQuery + } + + export interface PhraseSuggestCollateQuery { + id?: Id + source?: string + } + + export interface PhraseSuggestHighlight { + post_tag?: string + pre_tag?: string + } + + export interface PhraseSuggester { + collate?: PhraseSuggestCollate + confidence?: double + direct_generator?: DirectGenerator[] + force_unigrams?: boolean + gram_size?: integer + highlight?: PhraseSuggestHighlight + max_errors?: double + real_word_error_likelihood?: double + separator?: string + shard_size?: integer + smoothing?: SmoothingModelContainer + text?: string + token_limit?: integer + } + + export interface LaplaceSmoothingModel { + alpha?: double + } + + export interface LinearInterpolationSmoothingModel { + bigram_lambda?: double + trigram_lambda?: double + unigram_lambda?: double + } + + export interface SmoothingModel { + } + + export interface SmoothingModelContainer { + laplace?: LaplaceSmoothingModel + linear_interpolation?: LinearInterpolationSmoothingModel + stupid_backoff?: StupidBackoffSmoothingModel + } + + export interface StupidBackoffSmoothingModel { + discount?: double + } + + export interface TermSuggester { + lowercase_terms?: boolean + max_edits?: integer + max_inspections?: integer + max_term_freq?: float + min_doc_freq?: float + min_word_length?: integer + prefix_length?: integer + shard_size?: integer + sort?: SuggestSort + string_distance?: StringDistance + suggest_mode?: SuggestMode + text?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateQueryRequest extends RequestBase { + index?: Indices + type?: Types + allow_no_indices?: boolean + all_shards?: boolean + analyzer?: string + analyze_wildcard?: boolean + default_operator?: DefaultOperator + df?: string + expand_wildcards?: ExpandWildcards + explain?: boolean + ignore_unavailable?: boolean + lenient?: boolean + query_on_query_string?: string + rewrite?: boolean + body?: { + query?: QueryContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateQueryResponse { + explanations?: ValidationExplanation[] + _shards?: ShardStatistics + valid?: boolean + } + + export interface ValidationExplanation { + error?: string + explanation?: string + index?: string + valid?: boolean + } + + export interface AsyncSearch { + aggregations?: Record + _clusters?: ClusterStatistics + documents?: TDocument[] + fields?: Record + hits?: HitsMetadata + max_score?: double + num_reduce_phases?: long + profile?: Profile + _scroll_id?: string + _shards?: ShardStatistics + suggest?: SuggestDictionary + terminated_early?: boolean + timed_out?: boolean + took?: long + } + + export interface AsyncSearchResponseBase { + expiration_time?: Date + expiration_time_in_millis?: long + id?: string + is_partial?: boolean + is_running?: boolean + response?: AsyncSearch + start_time?: Date + start_time_in_millis?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchDeleteRequest extends RequestBase { + id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchDeleteResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchGetRequest extends RequestBase { + id: Id + body?: { + keep_alive?: Time + typed_keys?: boolean + wait_for_completion_timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchGetResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchSubmitRequest extends RequestBase { + index?: Indices + body?: { + aggs?: Record + allow_no_indices?: boolean + allow_partial_search_results?: boolean + analyzer?: string + analyze_wildcard?: boolean + batched_reduce_size?: long + collapse?: FieldCollapse + default_operator?: DefaultOperator + df?: string + docvalue_fields?: Field[] + expand_wildcards?: ExpandWildcards + explain?: boolean + from?: integer + highlight?: Highlight + ignore_throttled?: boolean + ignore_unavailable?: boolean + indices_boost?: Record + keep_alive?: Time + keep_on_completion?: boolean + lenient?: boolean + max_concurrent_shard_requests?: long + min_score?: double + post_filter?: QueryContainer + preference?: string + profile?: boolean + query?: QueryContainer + query_on_query_string?: string + request_cache?: boolean + rescore?: Rescore[] + routing?: Routing + script_fields?: Record + search_after?: object[] + search_type?: SearchType + sequence_number_primary_term?: boolean + size?: integer + sort?: Sort[] + _source?: boolean | SourceFilter + stats?: string[] + stored_fields?: Field[] + suggest?: Record + suggest_field?: Field + suggest_mode?: SuggestMode + suggest_size?: long + suggest_text?: string + terminate_after?: long + timeout?: string + track_scores?: boolean + track_total_hits?: boolean + typed_keys?: boolean + version?: boolean + wait_for_completion_timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface AsyncSearchSubmitResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateAutoFollowPatternRequest extends RequestBase { + name: Name + body?: { + follow_index_pattern?: string + leader_index_patterns?: string[] + max_outstanding_read_requests?: long + max_outstanding_write_requests?: integer + max_poll_timeout?: Time + max_read_request_operation_count?: integer + max_read_request_size?: string + max_retry_delay?: Time + max_write_buffer_count?: integer + max_write_buffer_size?: string + max_write_request_operation_count?: integer + max_write_request_size?: string + remote_cluster?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateAutoFollowPatternResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteAutoFollowPatternRequest extends RequestBase { + name: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteAutoFollowPatternResponse extends AcknowledgedResponseBase { + } + + export interface AutoFollowPattern { + follow_index_pattern?: string + leader_index_patterns?: string[] + max_outstanding_read_requests?: long + max_outstanding_write_requests?: integer + read_poll_timeout?: Time + max_read_request_operation_count?: integer + max_read_request_size?: string + max_retry_delay?: Time + max_write_buffer_count?: integer + max_write_buffer_size?: string + max_write_request_operation_count?: integer + max_write_request_size?: string + remote_cluster?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAutoFollowPatternRequest extends RequestBase { + name?: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAutoFollowPatternResponse { + patterns?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface PauseAutoFollowPatternRequest extends RequestBase { + name: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface PauseAutoFollowPatternResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ResumeAutoFollowPatternRequest extends RequestBase { + name: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface ResumeAutoFollowPatternResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateFollowIndexRequest extends RequestBase { + index: IndexName + wait_for_active_shards?: string + body?: { + leader_index?: IndexName + max_outstanding_read_requests?: long + max_outstanding_write_requests?: long + max_read_request_operation_count?: long + max_read_request_size?: string + max_retry_delay?: Time + max_write_buffer_count?: long + max_write_buffer_size?: string + max_write_request_operation_count?: long + max_write_request_size?: string + read_poll_timeout?: Time + remote_cluster?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateFollowIndexResponse { + follow_index_created?: boolean + follow_index_shards_acked?: boolean + index_following_started?: boolean + } + + export interface FollowIndexReadException { + exception?: ErrorCause + from_seq_no?: long + retries?: integer + } + + export interface FollowIndexShardStats { + bytes_read?: long + failed_read_requests?: long + failed_write_requests?: long + fatal_exception?: ErrorCause + follower_aliases_version?: long + follower_global_checkpoint?: long + follower_index?: string + follower_mapping_version?: long + follower_max_seq_no?: long + follower_settings_version?: long + last_requested_seq_no?: long + leader_global_checkpoint?: long + leader_index?: string + leader_max_seq_no?: long + operations_read?: long + operations_written?: long + outstanding_read_requests?: integer + outstanding_write_requests?: integer + read_exceptions?: FollowIndexReadException[] + remote_cluster?: string + shard_id?: integer + successful_read_requests?: long + successful_write_requests?: long + time_since_last_read_millis?: long + total_read_remote_exec_time_millis?: long + total_read_time_millis?: long + total_write_time_millis?: long + write_buffer_operation_count?: long + write_buffer_size_in_bytes?: long + } + + export interface FollowIndexStats { + index?: string + shards?: FollowIndexShardStats[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface FollowIndexStatsRequest extends RequestBase { + index: Indices + } + + /** + * @description Stability: UNSTABLE + */ + export interface FollowIndexStatsResponse { + indices?: FollowIndexStats[] + } + + export interface FollowConfig { + max_outstanding_read_requests?: integer + max_outstanding_write_requests?: integer + max_read_request_operation_count?: integer + max_read_request_size?: string + max_retry_delay?: Time + max_write_buffer_count?: integer + max_write_buffer_size?: string + max_write_request_operation_count?: integer + max_write_request_size?: string + read_poll_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface FollowInfoRequest extends RequestBase { + index: Indices + } + + /** + * @description Stability: UNSTABLE + */ + export interface FollowInfoResponse { + follower_indices?: FollowerInfo[] + } + + export interface FollowerInfo { + follower_index?: string + leader_index?: string + parameters?: FollowConfig + remote_cluster?: string + status?: FollowerIndexStatus + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForgetFollowerIndexRequest extends RequestBase { + index: IndexName + body?: { + follower_cluster?: string + follower_index?: IndexName + follower_index_uuid?: string + leader_remote_cluster?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForgetFollowerIndexResponse { + _shards?: ShardStatistics + } + + /** + * @description Stability: UNSTABLE + */ + export interface PauseFollowIndexRequest extends RequestBase { + index: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface PauseFollowIndexResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ResumeFollowIndexRequest extends RequestBase { + index: IndexName + body?: { + max_outstanding_read_requests?: long + max_outstanding_write_requests?: long + max_read_request_operation_count?: long + max_read_request_size?: string + max_retry_delay?: Time + max_write_buffer_count?: long + max_write_buffer_size?: string + max_write_request_operation_count?: long + max_write_request_size?: string + read_poll_timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ResumeFollowIndexResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface UnfollowIndexRequest extends RequestBase { + index: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface UnfollowIndexResponse extends AcknowledgedResponseBase { + } + + export interface AutoFollowedCluster { + cluster_name?: string + last_seen_metadata_version?: long + time_since_last_check_millis?: Date + } + + export interface CcrAutoFollowStats { + auto_followed_clusters?: AutoFollowedCluster[] + number_of_failed_follow_indices?: long + number_of_failed_remote_cluster_state_requests?: long + number_of_successful_follow_indices?: long + recent_auto_follow_errors?: ErrorCause[] + } + + export interface CcrFollowStats { + indices?: FollowIndexStats[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CcrStatsRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface CcrStatsResponse { + auto_follow_stats?: CcrAutoFollowStats + follow_stats?: CcrFollowStats + } + + export interface EnrichPolicy { + enrich_fields?: Field[] + indices?: Indices + match_field?: Field + query?: string + } + + export interface NamedPolicy extends EnrichPolicy { + name?: string + } + + export interface NamedPolicyConfig { + geo_match?: NamedPolicy + match?: NamedPolicy + } + + export interface NamedPolicyMetadata { + config?: NamedPolicyConfig + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteEnrichPolicyRequest extends RequestBase { + name: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteEnrichPolicyResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteEnrichPolicyRequest extends RequestBase { + name: Name + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteEnrichPolicyResponse { + status?: ExecuteEnrichPolicyStatus + task_id?: TaskId + } + + export interface ExecuteEnrichPolicyStatus { + phase?: EnrichPolicyPhase + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetEnrichPolicyRequest extends RequestBase { + name?: Names + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetEnrichPolicyResponse { + policies?: NamedPolicyMetadata[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutEnrichPolicyRequest extends RequestBase { + name: Name + body?: { + geo_match?: EnrichPolicy + match?: EnrichPolicy + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutEnrichPolicyResponse extends AcknowledgedResponseBase { + } + + export interface CoordinatorStats { + executed_searches_total?: long + node_id?: string + queue_size?: integer + remote_requests_current?: integer + remote_requests_total?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface EnrichStatsRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface EnrichStatsResponse { + coordinator_stats?: CoordinatorStats[] + executing_policies?: ExecutingPolicy[] + } + + export interface ExecutingPolicy { + name?: string + task?: TaskInfo + } + + /** + * @description Stability: UNSTABLE + */ + export interface GraphExploreRequest extends RequestBase { + index: Indices + type?: Types + routing?: Routing + timeout?: Time + body?: { + connections?: Hop + controls?: GraphExploreControls + query?: QueryContainer + vertices?: GraphVertexDefinition[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GraphExploreResponse { + connections?: GraphConnection[] + failures?: ShardFailure[] + timed_out?: boolean + took?: long + vertices?: GraphVertex[] + } + + export interface GraphExploreControls { + sample_diversity?: SampleDiversity + sample_size?: integer + timeout?: Time + use_significance?: boolean + } + + export interface GraphVertexDefinition { + exclude?: string[] + field?: Field + include?: GraphVertexInclude[] + min_doc_count?: long + shard_min_doc_count?: long + size?: integer + } + + export interface GraphVertexInclude { + boost?: double + term?: string + } + + export interface Hop { + connections?: Hop + query?: QueryContainer + vertices?: GraphVertexDefinition[] + } + + export interface SampleDiversity { + field?: Field + max_docs_per_value?: integer + } + + export interface GraphConnection { + doc_count?: long + source?: long + target?: long + weight?: double + } + + export interface GraphVertex { + depth?: long + field?: string + term?: string + weight?: double + } + + export interface Phase { + actions?: Record + min_age?: Time + } + + export interface Phases { + cold?: Phase + delete?: Phase + hot?: Phase + warm?: Phase + } + + export interface Policy { + phases?: Phases + } + + export interface LifecycleAction { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteLifecycleRequest extends RequestBase { + policy: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteLifecycleResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExplainLifecycleRequest extends RequestBase { + index: IndexName + only_errors?: boolean + only_managed?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExplainLifecycleResponse { + indices?: Record + } + + export interface LifecycleExplain { + action?: string + action_time_millis?: Date + age?: Time + failed_step?: string + failed_step_retry_count?: integer + index?: IndexName + is_auto_retryable_error?: boolean + lifecycle_date_millis?: Date + managed?: boolean + phase?: string + phase_time_millis?: Date + policy?: string + step?: string + step_info?: Record + step_time_millis?: Date + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetLifecycleRequest extends RequestBase { + policy?: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetLifecycleResponse extends Record { + } + + export interface LifecyclePolicy { + modified_date?: Date + policy?: Policy + version?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIlmStatusRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetIlmStatusResponse { + operation_mode?: LifecycleOperationMode + } + + /** + * @description Stability: UNSTABLE + */ + export interface MoveToStepRequest extends RequestBase { + index: IndexName + body?: { + current_step?: StepKey + next_step?: StepKey + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface MoveToStepResponse extends AcknowledgedResponseBase { + } + + export interface StepKey { + action?: string + name?: string + phase?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutLifecycleRequest extends RequestBase { + policy: Id + body?: { + policy?: Policy + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutLifecycleResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface RemovePolicyRequest extends RequestBase { + index: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface RemovePolicyResponse { + failed_indexes?: string[] + has_failures?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface RetryIlmRequest extends RequestBase { + index: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface RetryIlmResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartIlmRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartIlmResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopIlmRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopIlmResponse extends AcknowledgedResponseBase { + } + + export interface MinimalLicenseInformation { + expiry_date_in_millis?: long + mode?: LicenseType + status?: LicenseStatus + type?: LicenseType + uid?: string + } + + export interface NativeCodeInformation { + build_hash?: string + version?: string + } + + export interface XPackBuildInformation { + date?: Date + hash?: string + } + + export interface XPackFeature { + available?: boolean + description?: string + enabled?: boolean + native_code_info?: NativeCodeInformation + } + + export interface XPackFeatures { + analytics?: XPackFeature + ccr?: XPackFeature + data_frame?: XPackFeature + data_science?: XPackFeature + enrich?: XPackFeature + flattened?: XPackFeature + frozen_indices?: XPackFeature + graph?: XPackFeature + ilm?: XPackFeature + logstash?: XPackFeature + ml?: XPackFeature + monitoring?: XPackFeature + rollup?: XPackFeature + security?: XPackFeature + slm?: XPackFeature + spatial?: XPackFeature + sql?: XPackFeature + transform?: XPackFeature + vectors?: XPackFeature + voting_only?: XPackFeature + watcher?: XPackFeature + } + + /** + * @description Stability: UNSTABLE + */ + export interface XPackInfoRequest extends RequestBase { + categories?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface XPackInfoResponse { + build?: XPackBuildInformation + features?: XPackFeatures + license?: MinimalLicenseInformation + tagline?: string + } + + export interface AlertingCount { + active?: long + total?: long + } + + export interface AlertingExecution { + actions?: Record + } + + export interface AlertingInput { + input?: Record + trigger?: Record + } + + export interface AlertingUsage extends XPackUsage { + count?: AlertingCount + execution?: AlertingExecution + watch?: AlertingInput + } + + export interface AuditUsage extends SecurityFeatureToggle { + outputs?: string[] + } + + export interface CcrUsage extends XPackUsage { + auto_follow_patterns_count?: integer + follower_indices_count?: integer + } + + export interface DataFeed { + count?: long + } + + export interface ExecutionAction { + total?: long + total_in_ms?: long + } + + export interface FlattenedUsage extends XPackUsage { + field_count?: integer + } + + export interface ForecastStatistics { + forecasted_jobs?: long + memory_bytes?: JobStatistics + processing_time_ms?: JobStatistics + records?: JobStatistics + status?: Record + total?: long + } + + export interface IlmPolicyStatistics { + indices_managed?: integer + phases?: Phases + } + + export interface IlmUsage { + policy_count?: integer + policy_stats?: IlmPolicyStatistics[] + } + + export interface IpFilterUsage { + http?: boolean + transport?: boolean + } + + export interface Job { + allow_lazy_open?: boolean + analysis_config?: AnalysisConfig + analysis_limits?: AnalysisLimits + background_persist_interval?: Time + create_time?: Date + data_description?: DataDescription + description?: string + finished_time?: Date + job_id?: string + job_type?: string + model_plot?: ModelPlotConfig + model_snapshot_id?: string + model_snapshot_retention_days?: long + renormalization_window_days?: long + results_index_name?: string + results_retention_days?: long + } + + export interface JobStatistics { + avg?: double + max?: double + min?: double + total?: double + } + + export interface MachineLearningUsage extends XPackUsage { + datafeeds?: Record + jobs?: Record + node_count?: integer + } + + export interface MonitoringUsage extends XPackUsage { + collection_enabled?: boolean + enabled_exporters?: Record + } + + export interface QueryUsage { + count?: integer + failed?: integer + paging?: integer + total?: integer + } + + export interface RealmUsage extends XPackUsage { + name?: string[] + order?: long[] + size?: long[] + } + + export interface RoleMappingUsage { + enabled?: integer + size?: integer + } + + export interface RoleUsage { + dls?: boolean + fls?: boolean + size?: long + } + + export interface SecurityFeatureToggle { + enabled?: boolean + } + + export interface SecurityUsage extends XPackUsage { + anonymous?: SecurityFeatureToggle + audit?: AuditUsage + ipfilter?: IpFilterUsage + realms?: Record + role_mapping?: Record + roles?: Record + ssl?: SslUsage + system_key?: SecurityFeatureToggle + } + + export interface SlmUsage extends XPackUsage { + policy_count?: integer + policy_stats?: SnapshotLifecycleStats + } + + export interface SnapshotLifecycleStats { + retention_deletion_time?: string + retention_deletion_time_millis?: long + retention_failed?: long + retention_runs?: long + retention_timed_out?: long + total_snapshots_deleted?: long + total_snapshot_deletion_failures?: long + total_snapshots_failed?: long + total_snapshots_taken?: long + } + + export interface SqlUsage extends XPackUsage { + features?: Record + queries?: Record + } + + export interface SslUsage { + http?: SecurityFeatureToggle + transport?: SecurityFeatureToggle + } + + export interface VectorUsage extends XPackUsage { + dense_vector_dims_avg_count?: integer + dense_vector_fields_count?: integer + sparse_vector_fields_count?: integer + } + + export interface XPackUsage { + available?: boolean + enabled?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface XPackUsageRequest extends RequestBase { + master_timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface XPackUsageResponse { + watcher?: AlertingUsage + ccr?: CcrUsage + data_frame?: XPackUsage + data_science?: XPackUsage + enrich?: XPackUsage + flattened?: FlattenedUsage + graph?: XPackUsage + ilm?: IlmUsage + logstash?: XPackUsage + ml?: MachineLearningUsage + monitoring?: MonitoringUsage + rollup?: XPackUsage + security?: SecurityUsage + slm?: SlmUsage + sql?: SqlUsage + transform?: XPackUsage + vectors?: VectorUsage + voting_only?: XPackUsage + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteLicenseRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteLicenseResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBasicLicenseStatusRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBasicLicenseStatusResponse { + eligible_to_start_basic?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetLicenseRequest extends RequestBase { + accept_enterprise?: boolean + local?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetLicenseResponse { + license?: LicenseInformation + } + + export interface License { + expiry_date_in_millis?: long + issue_date_in_millis?: long + issued_to?: string + issuer?: string + max_nodes?: long + signature?: string + type?: LicenseType + uid?: string + } + + export interface LicenseInformation { + expiry_date?: Date + expiry_date_in_millis?: long + issue_date?: Date + issue_date_in_millis?: long + issued_to?: string + issuer?: string + max_nodes?: long + max_resource_units?: integer + status?: LicenseStatus + type?: LicenseType + uid?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTrialLicenseStatusRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTrialLicenseStatusResponse { + eligible_to_start_trial?: boolean + } + + export interface LicenseAcknowledgement { + license?: string[] + message?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostLicenseRequest extends RequestBase { + acknowledge?: boolean + body?: { + license?: License + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostLicenseResponse { + acknowledge?: LicenseAcknowledgement + acknowledged?: boolean + license_status?: LicenseStatus + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartBasicLicenseRequest extends RequestBase { + acknowledge?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartBasicLicenseResponse extends AcknowledgedResponseBase { + acknowledge?: Record + basic_was_started?: boolean + error_message?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartTrialLicenseRequest extends RequestBase { + acknowledge?: boolean + type_query_string?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartTrialLicenseResponse extends AcknowledgedResponseBase { + error_message?: string + trial_was_started?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloseJobRequest extends RequestBase { + job_id: Id + allow_no_jobs?: boolean + force?: boolean + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface CloseJobResponse { + closed?: boolean + } + + export interface ChunkingConfig { + mode?: ChunkingMode + time_span?: Time + } + + export interface DatafeedConfig { + aggregations?: Record + chunking_config?: ChunkingConfig + datafeed_id?: string + frequency?: Time + indices?: Indices + job_id?: string + max_empty_searches?: integer + query?: QueryContainer + query_delay?: Time + script_fields?: Record + scroll_size?: integer + } + + export interface DatafeedStats { + assignment_explanation?: string + datafeed_id?: string + node?: DiscoveryNode + state?: DatafeedState + timing_stats?: DatafeedTimingStats + } + + export interface DatafeedTimingStats { + bucket_count?: long + exponential_average_search_time_per_hour_ms?: double + job_id?: string + search_count?: long + total_search_time_ms?: double + } + + export interface DiscoveryNode { + attributes?: Record + ephemeral_id?: string + id?: string + name?: string + transport_address?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarRequest extends RequestBase { + calendar_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarEventRequest extends RequestBase { + calendar_id: Id + event_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarEventResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarJobRequest extends RequestBase { + calendar_id: Id + job_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteCalendarJobResponse { + calendar_id?: string + description?: string + job_ids?: Id[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteDatafeedRequest extends RequestBase { + datafeed_id: Id + force?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteDatafeedResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteExpiredDataRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteExpiredDataResponse { + deleted?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteFilterRequest extends RequestBase { + filter_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteFilterResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteForecastRequest extends RequestBase { + job_id: Id + forecast_id?: Id + allow_no_forecasts?: boolean + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteForecastResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteJobRequest extends RequestBase { + job_id: Id + force?: boolean + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteJobResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteModelSnapshotRequest extends RequestBase { + job_id: Id + snapshot_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteModelSnapshotResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface EstimateModelMemoryRequest extends RequestBase { + body?: { + analysis_config?: AnalysisConfig + max_bucket_cardinality?: Record + overall_cardinality?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface EstimateModelMemoryResponse { + model_memory_estimate?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface FlushJobRequest extends RequestBase { + job_id: Id + skip_time?: string + body?: { + advance_time?: Date + calc_interim?: boolean + end?: Date + start?: Date + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface FlushJobResponse { + flushed?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForecastJobRequest extends RequestBase { + job_id: Id + body?: { + duration?: Time + expires_in?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ForecastJobResponse extends AcknowledgedResponseBase { + forecast_id?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAnomalyRecordsRequest extends RequestBase { + job_id: Id + body?: { + desc?: boolean + end?: Date + exclude_interim?: boolean + page?: Page + record_score?: double + sort?: Field + start?: Date + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetAnomalyRecordsResponse { + count?: long + records?: AnomalyRecord[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBucketsRequest extends RequestBase { + job_id: Id + timestamp?: Timestamp + body?: { + anomaly_score?: double + desc?: boolean + end?: Date + exclude_interim?: boolean + expand?: boolean + page?: Page + sort?: Field + start?: Date + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBucketsResponse { + buckets?: Bucket[] + count?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCalendarEventsRequest extends RequestBase { + calendar_id: Id + end?: Date + job_id?: string + start?: string + body?: { + from?: integer + size?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCalendarEventsResponse { + count?: integer + events?: ScheduledEvent[] + } + + export interface Calendar { + calendar_id?: string + description?: string + job_ids?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCalendarsRequest extends RequestBase { + calendar_id?: Id + body?: { + page?: Page + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCalendarsResponse { + calendars?: Calendar[] + count?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCategoriesRequest extends RequestBase { + job_id: Id + category_id?: CategoryId + body?: { + page?: Page + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCategoriesResponse { + categories?: CategoryDefinition[] + count?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetDatafeedStatsRequest extends RequestBase { + datafeed_id?: Id + allow_no_datafeeds?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetDatafeedStatsResponse { + count?: long + datafeeds?: DatafeedStats[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetDatafeedsRequest extends RequestBase { + datafeed_id?: Id + allow_no_datafeeds?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetDatafeedsResponse { + count?: long + datafeeds?: DatafeedConfig[] + } + + export interface Filter { + description?: string + filter_id?: string + items?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetFiltersRequest extends RequestBase { + filter_id?: Id + from?: integer + size?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetFiltersResponse { + count?: long + filters?: Filter[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetInfluencersRequest extends RequestBase { + job_id: Id + body?: { + descending?: boolean + end?: Date + exclude_interim?: boolean + influencer_score?: double + page?: Page + sort?: Field + start?: Date + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetInfluencersResponse { + count?: long + influencers?: BucketInfluencer[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetJobStatsRequest extends RequestBase { + job_id?: Id + allow_no_jobs?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetJobStatsResponse { + count?: long + jobs?: JobStats[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetJobsRequest extends RequestBase { + job_id?: Id + allow_no_jobs?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetJobsResponse { + count?: long + jobs?: Job[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetModelSnapshotsRequest extends RequestBase { + job_id: Id + snapshot_id?: Id + body?: { + desc?: boolean + end?: Date + page?: Page + sort?: Field + start?: Date + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetModelSnapshotsResponse { + count?: long + model_snapshots?: ModelSnapshot[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetOverallBucketsRequest extends RequestBase { + job_id: Id + body?: { + allow_no_jobs?: boolean + bucket_span?: Time + end?: Date + exclude_interim?: boolean + overall_score?: double + start?: Date + top_n?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetOverallBucketsResponse { + count?: long + overall_buckets?: OverallBucket[] + } + + export interface Page { + from?: integer + size?: integer + } + + export interface AnalysisConfig { + bucket_span?: Time + categorization_field_name?: Field + categorization_filters?: string[] + detectors?: Detector[] + influencers?: Field[] + latency?: Time + multivariate_by_fields?: boolean + summary_count_field_name?: Field + } + + export interface AnalysisLimits { + categorization_examples_limit?: long + model_memory_limit?: string + } + + export interface AnalysisMemoryLimit { + model_memory_limit?: string + } + + export interface DataDescription { + format?: string + time_field?: Field + time_format?: string + } + + export interface JobForecastStatistics { + memory_bytes?: JobStatistics + processing_time_ms?: JobStatistics + records?: JobStatistics + status?: Record + total?: long + } + + export interface JobStats { + assignment_explanation?: string + data_counts?: DataCounts + forecasts_stats?: JobForecastStatistics + job_id?: string + model_size_stats?: ModelSizeStats + node?: DiscoveryNode + open_time?: Time + state?: JobState + timing_stats?: TimingStats + } + + export interface ModelPlotConfig { + terms?: Field[] + } + + export interface ModelPlotConfigEnabled { + enabled?: boolean + } + + export interface TimingStats { + average_bucket_processing_time_ms?: double + bucket_count?: long + exponential_average_bucket_processing_time_ms?: double + exponential_average_bucket_processing_time_per_hour_ms?: double + job_id?: string + maximum_bucket_processing_time_ms?: double + minimum_bucket_processing_time_ms?: double + } + + export interface DetectionRule { + actions?: RuleAction[] + conditions?: RuleCondition[] + scope?: Record + } + + export interface Detector { + custom_rules?: DetectionRule[] + detector_description?: string + detector_index?: integer + exclude_frequent?: ExcludeFrequent + function?: string + use_null?: boolean + } + + export interface FilterRef { + filter_id?: Id + filter_type?: RuleFilterType + } + + export interface RuleCondition { + applies_to?: AppliesTo + operator?: ConditionOperator + value?: double + } + + export interface DataCounts { + bucket_count?: long + earliest_record_timestamp?: Date + empty_bucket_count?: long + input_bytes?: long + input_field_count?: long + input_record_count?: long + invalid_date_count?: long + job_id?: string + last_data_time?: Date + latest_empty_bucket_timestamp?: Date + latest_record_timestamp?: Date + latest_sparse_bucket_timestamp?: Date + missing_field_count?: long + out_of_order_timestamp_count?: long + processed_field_count?: long + processed_record_count?: long + sparse_bucket_count?: long + } + + export interface ModelSizeStats { + bucket_allocation_failures_count?: long + job_id?: string + log_time?: Date + memory_status?: MemoryStatus + model_bytes?: long + result_type?: string + timestamp?: Date + total_by_field_count?: long + total_over_field_count?: long + total_partition_field_count?: long + } + + export interface ModelSnapshot { + description?: string + job_id?: string + latest_record_time_stamp?: Date + latest_result_time_stamp?: Date + model_size_stats?: ModelSizeStats + retain?: boolean + snapshot_doc_count?: long + snapshot_id?: string + timestamp?: Date + } + + export interface AnomalyCause { + actual?: double[] + by_field_name?: string + by_field_value?: string + correlated_by_field_value?: string + field_name?: string + function?: string + function_description?: string + influencers?: Influence[] + over_field_name?: string + over_field_value?: string + partition_field_name?: string + partition_field_value?: string + probability?: double + typical?: double[] + } + + export interface AnomalyRecord { + actual?: double[] + bucket_span?: Time + by_field_name?: string + by_field_value?: string + causes?: AnomalyCause[] + detector_index?: integer + field_name?: string + function?: string + function_description?: string + influencers?: Influence[] + initial_record_score?: double + is_interim?: boolean + job_id?: string + over_field_name?: string + over_field_value?: string + partition_field_name?: string + partition_field_value?: string + probability?: double + record_score?: double + result_type?: string + timestamp?: Date + typical?: double[] + } + + export interface Bucket { + anomaly_score?: double + bucket_influencers?: BucketInfluencer[] + bucket_span?: Time + event_count?: long + initial_anomaly_score?: double + is_interim?: boolean + job_id?: string + partition_scores?: PartitionScore[] + processing_time_ms?: double + result_type?: string + timestamp?: Date + } + + export interface BucketInfluencer { + bucket_span?: long + influencer_field_name?: string + influencer_field_value?: string + influencer_score?: double + initial_influencer_score?: double + is_interim?: boolean + job_id?: string + probability?: double + result_type?: string + timestamp?: Date + } + + export interface CategoryDefinition { + category_id?: long + examples?: string[] + job_id?: string + max_matching_length?: long + regex?: string + terms?: string + } + + export interface Influence { + influencer_field_name?: string + influencer_field_values?: string[] + } + + export interface OverallBucket { + bucket_span?: long + is_interim?: boolean + jobs?: OverallBucketJobInfo[] + overall_score?: double + result_type?: string + timestamp?: Date + } + + export interface OverallBucketJobInfo { + job_id?: string + max_anomaly_score?: double + } + + export interface PartitionScore { + initial_record_score?: double + partition_field_name?: string + partition_field_value?: string + probability?: double + record_score?: double + } + + export interface AnomalyDetectors { + categorization_analyzer?: CategorizationAnalyzer + categorization_examples_limit?: integer + model_memory_limit?: string + model_snapshot_retention_days?: integer + } + + export interface CategorizationAnalyzer { + filter?: ITokenFilter[] + tokenizer?: string + } + + export interface Datafeeds { + scroll_size?: integer + } + + export interface Defaults { + anomaly_detectors?: AnomalyDetectors + datafeeds?: Datafeeds + } + + export interface Limits { + max_model_memory_limit?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface MachineLearningInfoRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface MachineLearningInfoResponse { + defaults?: Defaults + limits?: Limits + upgrade_mode?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface OpenJobRequest extends RequestBase { + job_id: Id + body?: { + timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface OpenJobResponse { + opened?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostCalendarEventsRequest extends RequestBase { + calendar_id: Id + body?: { + events?: ScheduledEvent[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostCalendarEventsResponse { + events?: ScheduledEvent[] + } + + export interface ScheduledEvent { + calendar_id?: Id + description?: string + end_time?: Date + event_id?: Id + start_time?: Date + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostJobDataRequest extends RequestBase { + job_id: Id + reset_end?: Date + reset_start?: Date + body?: { + data?: object[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PostJobDataResponse { + bucket_count?: long + earliest_record_timestamp?: Date + empty_bucket_count?: long + input_bytes?: long + input_field_count?: long + input_record_count?: long + invalid_date_count?: long + job_id?: string + last_data_time?: Date + latest_record_timestamp?: Date + missing_field_count?: long + out_of_order_timestamp_count?: long + processed_field_count?: long + processed_record_count?: long + sparse_bucket_count?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface PreviewDatafeedRequest extends RequestBase { + datafeed_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface PreviewDatafeedResponse { + data?: TDocument[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutCalendarRequest extends RequestBase { + calendar_id: Id + body?: { + description?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutCalendarResponse { + calendar_id?: string + description?: string + job_ids?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutCalendarJobRequest extends RequestBase { + calendar_id: Id + job_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutCalendarJobResponse { + calendar_id?: string + description?: string + job_ids?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutDatafeedRequest extends RequestBase { + datafeed_id: Id + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_throttled?: boolean + ignore_unavailable?: boolean + body?: { + aggregations?: Record + chunking_config?: ChunkingConfig + frequency?: Time + indices?: Indices + job_id?: Id + max_empty_searches?: integer + query?: QueryContainer + query_delay?: Time + script_fields?: Record + scroll_size?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutDatafeedResponse { + aggregations?: Record + chunking_config?: ChunkingConfig + datafeed_id?: string + frequency?: Time + indices?: Indices + job_id?: string + max_empty_searches?: integer + query?: QueryContainer + query_delay?: Time + script_fields?: Record + scroll_size?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutFilterRequest extends RequestBase { + filter_id: Id + body?: { + description?: string + items?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutFilterResponse { + description?: string + filter_id?: string + items?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutJobRequest extends RequestBase { + job_id: Id + body?: { + allow_lazy_open?: boolean + analysis_config?: AnalysisConfig + analysis_limits?: AnalysisLimits + data_description?: DataDescription + description?: string + model_plot?: ModelPlotConfig + model_snapshot_retention_days?: long + results_index_name?: IndexName + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutJobResponse { + allow_lazy_open?: boolean + analysis_config?: AnalysisConfig + analysis_limits?: AnalysisLimits + background_persist_interval?: Time + create_time?: Date + data_description?: DataDescription + description?: string + job_id?: string + job_type?: string + model_plot?: ModelPlotConfig + model_snapshot_id?: string + model_snapshot_retention_days?: long + renormalization_window_days?: long + results_index_name?: string + results_retention_days?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface RevertModelSnapshotRequest extends RequestBase { + job_id: Id + snapshot_id: Id + body?: { + delete_intervening_results?: boolean + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RevertModelSnapshotResponse { + model?: ModelSnapshot + } + + /** + * @description Stability: UNSTABLE + */ + export interface SetUpgradeModeRequest extends RequestBase { + enabled?: boolean + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface SetUpgradeModeResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartDatafeedRequest extends RequestBase { + datafeed_id: Id + body?: { + end?: Date + start?: Date + timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartDatafeedResponse { + started?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopDatafeedRequest extends RequestBase { + datafeed_id: Id + allow_no_datafeeds?: boolean + body?: { + force?: boolean + timeout?: Time + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopDatafeedResponse { + stopped?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateDatafeedRequest extends RequestBase { + datafeed_id: Id + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_throttled?: boolean + ignore_unavailable?: boolean + body?: { + aggregations?: Record + chunking_config?: ChunkingConfig + frequency?: Time + indices?: Indices + job_id?: Id + max_empty_searches?: integer + query?: QueryContainer + query_delay?: Time + script_fields?: Record + scroll_size?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateDatafeedResponse { + aggregations?: Record + chunking_config?: ChunkingConfig + datafeed_id?: string + frequency?: Time + indices?: Indices + job_id?: string + max_empty_searches?: integer + query?: QueryContainer + query_delay?: Time + script_fields?: Record + scroll_size?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateFilterRequest extends RequestBase { + filter_id: Id + body?: { + add_items?: string[] + description?: string + remove_items?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateFilterResponse { + description?: string + filter_id?: string + items?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateJobRequest extends RequestBase { + job_id: Id + body?: { + allow_lazy_open?: boolean + analysis_limits?: AnalysisMemoryLimit + background_persist_interval?: Time + custom_settings?: Record + description?: string + model_plot_config?: ModelPlotConfigEnabled + model_snapshot_retention_days?: long + renormalization_window_days?: long + results_retention_days?: long + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateJobResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateModelSnapshotRequest extends RequestBase { + job_id: Id + snapshot_id: Id + body?: { + description?: string + retain?: boolean + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateModelSnapshotResponse extends AcknowledgedResponseBase { + model?: ModelSnapshot + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateDetectorRequest extends RequestBase { + body?: { + detector?: Detector + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateDetectorResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateJobRequest extends RequestBase { + body?: { + analysis_config?: AnalysisConfig + analysis_limits?: AnalysisLimits + data_description?: DataDescription + description?: string + model_plot?: ModelPlotConfig + model_snapshot_retention_days?: long + results_index_name?: IndexName + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ValidateJobResponse extends AcknowledgedResponseBase { + } + + export interface DeprecationInfo { + details?: string + level?: DeprecationWarningLevel + message?: string + url?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeprecationInfoRequest extends RequestBase { + index?: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeprecationInfoResponse { + cluster_settings?: DeprecationInfo[] + index_settings?: Record + node_settings?: DeprecationInfo[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateRollupJobRequest extends RequestBase { + id: Id + body?: { + cron?: string + groups?: RollupGroupings + index_pattern?: string + metrics?: RollupFieldMetric[] + page_size?: long + rollup_index?: IndexName + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateRollupJobResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRollupJobRequest extends RequestBase { + id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRollupJobResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupCapabilitiesRequest extends RequestBase { + id?: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupCapabilitiesResponse extends Record { + } + + export interface RollupCapabilities { + rollup_jobs?: RollupCapabilitiesJob[] + } + + export interface RollupCapabilitiesJob { + fields?: Record> + index_pattern?: string + job_id?: string + rollup_index?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupIndexCapabilitiesRequest extends RequestBase { + index: IndexName + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupIndexCapabilitiesResponse extends Record { + } + + export interface RollupIndexCapabilities { + rollup_jobs?: RollupIndexCapabilitiesJob[] + } + + export interface RollupIndexCapabilitiesJob { + fields?: Record> + index_pattern?: string + job_id?: string + rollup_index?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupJobRequest extends RequestBase { + id?: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRollupJobResponse { + jobs?: RollupJobInformation[] + } + + export interface RollupJobConfiguration { + cron?: string + groups?: RollupGroupings + id?: string + index_pattern?: string + metrics?: RollupFieldMetric[] + page_size?: long + rollup_index?: IndexName + timeout?: Time + } + + export interface RollupJobInformation { + config?: RollupJobConfiguration + stats?: RollupJobStats + status?: RollupJobStatus + } + + export interface RollupJobStats { + documents_processed?: long + index_failures?: long + index_time_in_ms?: long + index_total?: long + pages_processed?: long + rollups_indexed?: long + search_failures?: long + search_time_in_ms?: long + search_total?: long + trigger_count?: long + } + + export interface RollupJobStatus { + current_position?: Record + job_state?: IndexingJobState + upgraded_doc_id?: boolean + } + + export interface DateHistogramRollupGrouping { + delay?: Time + field?: Field + format?: string + interval?: Time + time_zone?: string + } + + export interface HistogramRollupGrouping { + fields?: Field[] + interval?: long + } + + export interface RollupFieldMetric { + field?: Field + metrics?: RollupMetric[] + } + + export interface RollupGroupings { + date_histogram?: DateHistogramRollupGrouping + histogram?: HistogramRollupGrouping + terms?: TermsRollupGrouping + } + + export interface TermsRollupGrouping { + fields?: Field[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface RollupSearchRequest extends RequestBase { + index: Indices + type?: TypeName + total_hits_as_integer?: boolean + typed_keys?: boolean + body?: { + aggs?: Record + query?: QueryContainer + size?: integer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface RollupSearchResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartRollupJobRequest extends RequestBase { + id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartRollupJobResponse { + started?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopRollupJobRequest extends RequestBase { + id: Id + timeout?: Time + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopRollupJobResponse { + stopped?: boolean + } + + export interface SecurityNode { + name?: string + } + + export interface ApiKeyPrivileges { + names?: string[] + privileges?: string[] + } + + export interface ApiKeyRole { + cluster?: string[] + index?: ApiKeyPrivileges[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateApiKeyRequest extends RequestBase { + refresh?: Refresh + body?: { + expiration?: Time + name?: string + role_descriptors?: Record + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface CreateApiKeyResponse { + api_key?: string + expiration?: Date + id?: string + name?: string + } + + export interface ApiKeys { + creation?: Date + expiration?: Date + id?: string + invalidated?: boolean + name?: string + realm?: string + username?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetApiKeyRequest extends RequestBase { + id?: string + name?: string + owner?: boolean + realm_name?: string + username?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetApiKeyResponse { + api_keys?: ApiKeys[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface InvalidateApiKeyRequest extends RequestBase { + body?: { + id?: string + name?: string + owner?: boolean + realm_name?: string + username?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface InvalidateApiKeyResponse { + error_count?: integer + error_details?: ErrorCause[] + invalidated_api_keys?: string[] + previously_invalidated_api_keys?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface AuthenticateRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface AuthenticateResponse { + authentication_realm?: RealmInfo + email?: string + full_name?: string + lookup_realm?: RealmInfo + metadata?: Record + roles?: string[] + username?: string + } + + export interface RealmInfo { + name?: string + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCachedRealmsRequest extends RequestBase { + realms: Names + usernames?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCachedRealmsResponse { + cluster_name?: string + nodes?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeletePrivilegesRequest extends RequestBase { + application: Name + name: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeletePrivilegesResponse extends Record> { + } + + export interface FoundUserPrivilege { + found?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBuiltinPrivilegesRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetBuiltinPrivilegesResponse { + cluster?: string[] + index?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetPrivilegesRequest extends RequestBase { + application?: Name + name?: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetPrivilegesResponse extends Record> { + } + + export interface ApplicationGlobalUserPrivileges { + manage?: ManageUserPrivileges + } + + export interface ApplicationResourcePrivileges { + application?: string + privileges?: string[] + resources?: string[] + } + + export interface FieldSecuritySettings { + except?: string[] + grant?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserPrivilegesRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserPrivilegesResponse { + applications?: ApplicationResourcePrivileges[] + cluster?: string[] + global?: GlobalPrivileges[] + indices?: UserIndicesPrivileges[] + run_as?: string[] + } + + export interface GlobalPrivileges { + application?: ApplicationGlobalUserPrivileges + } + + export interface ManageUserPrivileges { + applications?: string[] + } + + export interface QueryUserPrivileges { + term?: TermUserPrivileges + } + + export interface TermUserPrivileges { + apps?: boolean + } + + export interface UserIndicesPrivileges { + field_security?: FieldSecuritySettings + names?: string[] + privileges?: string[] + query?: QueryUserPrivileges + } + + export interface ApplicationPrivilegesCheck { + application?: string + privileges?: string[] + resources?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface HasPrivilegesRequest extends RequestBase { + user?: Name + body?: { + application?: ApplicationPrivilegesCheck[] + cluster?: string[] + index?: IndexPrivilegesCheck[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface HasPrivilegesResponse { + application?: Record + cluster?: Record + has_all_requested?: boolean + index?: ResourcePrivileges[] + username?: string + } + + export interface IndexPrivilegesCheck { + names?: string[] + privileges?: string[] + } + + export interface ResourcePrivileges { + privileges?: Record + resource?: string + } + + export interface PrivilegesActions { + actions?: string[] + metadata?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutPrivilegesRequest extends RequestBase { + refresh?: Refresh + body?: { + applications?: Record> + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutPrivilegesResponse extends Record> { + } + + export interface PutPrivilegesStatus { + created?: boolean + } + + export interface FieldSecurity { + except?: Field[] + grant?: Field[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCachedRolesRequest extends RequestBase { + name: Names + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearCachedRolesResponse { + cluster_name?: string + nodes?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRoleRequest extends RequestBase { + name: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRoleResponse { + found?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRoleRequest extends RequestBase { + name?: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRoleResponse extends Record { + } + + export interface XPackRole { + cluster?: string[] + indices?: IndicesPrivileges[] + metadata?: Record + run_as?: string[] + } + + export interface ApplicationPrivileges { + application?: string + privileges?: string[] + resources?: string[] + } + + export interface IndicesPrivileges { + field_security?: FieldSecurity + names?: Indices + privileges?: string[] + query?: QueryContainer + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutRoleRequest extends RequestBase { + name: Name + refresh?: Refresh + body?: { + applications?: ApplicationPrivileges[] + cluster?: string[] + global?: Record + indices?: IndicesPrivileges[] + metadata?: Record + run_as?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutRoleResponse { + role?: PutRoleStatus + } + + export interface PutRoleStatus { + created?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRoleMappingRequest extends RequestBase { + name: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteRoleMappingResponse { + found?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRoleMappingRequest extends RequestBase { + name?: Name + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetRoleMappingResponse extends Record { + } + + export interface XPackRoleMapping { + enabled?: boolean + metadata?: Record + roles?: string[] + rules?: RoleMappingRuleBase + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutRoleMappingRequest extends RequestBase { + name: Name + refresh?: Refresh + body?: { + enabled?: boolean + metadata?: Record + roles?: string[] + rules?: RoleMappingRuleBase + run_as?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutRoleMappingResponse { + created?: boolean + role_mapping?: PutRoleMappingStatus + } + + export interface PutRoleMappingStatus { + created?: boolean + } + + export interface RoleMappingRuleBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ChangePasswordRequest extends RequestBase { + username?: Name + refresh?: Refresh + body?: { + password?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ChangePasswordResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteUserRequest extends RequestBase { + username: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteUserResponse { + found?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DisableUserRequest extends RequestBase { + username: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface DisableUserResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface EnableUserRequest extends RequestBase { + username: Name + refresh?: Refresh + } + + /** + * @description Stability: UNSTABLE + */ + export interface EnableUserResponse { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserRequest extends RequestBase { + username?: Names + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserResponse extends Record { + } + + export interface XPackUser { + email?: string + full_name?: string + metadata?: Record + roles?: string[] + username?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserAccessTokenRequest extends RequestBase { + body?: { + grant_type?: AccessTokenGrantType + scope?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetUserAccessTokenResponse { + access_token?: string + expires_in?: long + scope?: string + type?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface InvalidateUserAccessTokenRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface InvalidateUserAccessTokenResponse { + error_count?: long + error_details?: ErrorCause[] + invalidated_tokens?: long + previously_invalidated_tokens?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutUserRequest extends RequestBase { + username: Name + refresh?: Refresh + body?: { + email?: string + full_name?: string + metadata?: Record + password?: string + password_hash?: string + roles?: string[] + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutUserResponse { + created?: boolean + } + + export interface SnapshotLifecycleConfig { + ignore_unavailable?: boolean + include_global_state?: boolean + indices?: Indices + } + + export interface SnapshotLifecycleInProgress { + name?: string + start_time_millis?: Date + state?: string + uuid?: string + } + + export interface SnapshotLifecycleInvocationRecord { + snapshot_name?: string + time?: Date + } + + export interface SnapshotLifecyclePolicy { + config?: SnapshotLifecycleConfig + name?: string + repository?: string + retention?: SnapshotRetentionConfiguration + schedule?: CronExpression + } + + export interface SnapshotLifecyclePolicyMetadata { + in_progress?: SnapshotLifecycleInProgress + last_failure?: SnapshotLifecycleInvocationRecord + last_success?: SnapshotLifecycleInvocationRecord + modified_date_millis?: Date + next_execution_millis?: Date + policy?: SnapshotLifecyclePolicy + version?: integer + } + + export interface SnapshotRetentionConfiguration { + expire_after?: Time + max_count?: integer + min_count?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteSnapshotLifecycleRequest extends RequestBase { + policy_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteSnapshotLifecycleResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteSnapshotLifecycleRequest extends RequestBase { + policy_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteSnapshotLifecycleResponse { + snapshot_name?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteRetentionRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteRetentionResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleRequest extends RequestBase { + policy_id?: Ids + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleResponse extends Record { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleStatsRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleStatsResponse { + retention_deletion_time?: string + retention_deletion_time_millis?: long + retention_failed?: long + retention_runs?: long + retention_timed_out?: long + total_snapshots_deleted?: long + total_snapshot_deletion_failures?: long + total_snapshots_failed?: long + total_snapshots_taken?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleManagementStatusRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetSnapshotLifecycleManagementStatusResponse { + operation_mode?: LifecycleOperationMode + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutSnapshotLifecycleRequest extends RequestBase { + policy_id: Id + body?: { + config?: SnapshotLifecycleConfig + name?: string + repository?: string + retention?: SnapshotRetentionConfiguration + schedule?: CronExpression + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutSnapshotLifecycleResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartSnapshotLifecycleManagementRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartSnapshotLifecycleManagementResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopSnapshotLifecycleManagementRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopSnapshotLifecycleManagementResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface SqlRequest { + fetch_size?: integer + filter?: QueryContainer + query?: string + time_zone?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearSqlCursorRequest extends RequestBase { + body?: { + cursor?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ClearSqlCursorResponse { + succeeded?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface QuerySqlRequest extends RequestBase { + format?: string + body?: { + columnar?: boolean + cursor?: string + fetch_size?: integer + filter?: QueryContainer + query?: string + time_zone?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface QuerySqlResponse { + columns?: SqlColumn[] + cursor?: string + rows?: SqlValue[][] + values?: SqlValue[][] + } + + export interface SqlColumn { + name?: string + type?: string + } + + export interface SqlValue extends LazyDocument { + } + + /** + * @description Stability: UNSTABLE + */ + export interface TranslateSqlRequest extends RequestBase { + body?: { + fetch_size?: integer + filter?: QueryContainer + query?: string + time_zone?: string + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface TranslateSqlResponse { + result?: SearchRequest + } + + export interface ClusterCertificateInformation { + alias?: string + expiry?: Date + format?: string + has_private_key?: boolean + path?: string + serial_number?: string + subject_dn?: string + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCertificatesRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetCertificatesResponse { + certificates?: ClusterCertificateInformation[] + } + + export interface TransformDestination { + index?: IndexName + pipeline?: string + } + + export interface TransformSource { + index?: Indices + query?: QueryContainer + } + + export interface TransformSync { + } + + export interface TransformSyncContainer { + time?: TransformTimeSync + } + + export interface TransformTimeSync { + delay?: Time + field?: Field + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteTransformRequest extends RequestBase { + transform_id: Id + force?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteTransformResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTransformRequest extends RequestBase { + transform_id?: Id + allow_no_match?: boolean + from?: integer + size?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTransformResponse { + count?: long + transforms?: Transform[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTransformStatsRequest extends RequestBase { + transform_id: Id + allow_no_match?: boolean + from?: long + size?: long + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetTransformStatsResponse { + count?: long + transforms?: TransformStats[] + } + + export interface NodeAttributes { + attributes?: Record + ephemeral_id?: string + id?: string + name?: string + transport_address?: string + } + + export interface TransformCheckpointStats { + checkpoint?: long + checkpoint_progress?: TransformProgress + timestamp?: Date + timestamp_millis?: long + time_upper_bound?: Date + time_upper_bound_millis?: long + } + + export interface TransformCheckpointingInfo { + changes_last_detected_at?: long + changes_last_detected_at_date_time?: Date + last?: TransformCheckpointStats + next?: TransformCheckpointStats + operations_behind?: long + } + + export interface TransformIndexerStats { + documents_indexed?: long + documents_processed?: long + exponential_avg_checkpoint_duration_ms?: double + exponential_avg_documents_indexed?: double + exponential_avg_documents_processed?: double + index_failures?: long + index_time_in_ms?: long + index_total?: long + pages_processed?: long + processing_time_in_ms?: long + processing_total?: long + search_failures?: long + search_time_in_ms?: long + search_total?: long + trigger_count?: long + } + + export interface TransformProgress { + docs_indexed?: long + docs_processed?: long + docs_remaining?: long + percent_complete?: double + total_docs?: long + } + + export interface TransformStats { + checkpointing?: TransformCheckpointingInfo + id?: string + node?: NodeAttributes + reason?: string + state?: string + stats?: TransformIndexerStats + } + + export interface SingleGroupSource { + field?: Field + script?: Script + } + + export interface TransformPivot { + aggregations?: Record + group_by?: Record + max_page_search_size?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface PreviewTransformRequest extends RequestBase { + body?: { + description?: string + dest?: TransformDestination + frequency?: Time + pivot?: TransformPivot + source?: TransformSource + sync?: TransformSyncContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PreviewTransformResponse { + generated_dest_index?: IndexState + preview?: TTransform[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutTransformRequest extends RequestBase { + transform_id: Id + defer_validation?: boolean + body?: { + description?: string + dest?: TransformDestination + frequency?: Time + pivot?: TransformPivot + source?: TransformSource + sync?: TransformSyncContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutTransformResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartTransformRequest extends RequestBase { + transform_id: Id + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartTransformResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopTransformRequest extends RequestBase { + transform_id: Id + allow_no_match?: boolean + force?: boolean + timeout?: Time + wait_for_checkpoint?: boolean + wait_for_completion?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopTransformResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateTransformRequest extends RequestBase { + transform_id: Id + defer_validation?: boolean + body?: { + description?: string + dest?: TransformDestination + frequency?: Time + source?: TransformSource + sync?: TransformSyncContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface UpdateTransformResponse { + create_time?: long + create_time_date_time?: Date + description?: string + dest?: TransformDestination + frequency?: Time + id?: string + pivot?: TransformPivot + source?: TransformSource + sync?: TransformSyncContainer + version?: string + } + + export interface Watch { + actions?: Record + condition?: ConditionContainer + input?: InputContainer + metadata?: Record + status?: WatchStatus + throttle_period?: string + transform?: TransformContainer + trigger?: TriggerContainer + } + + export interface AcknowledgeState { + state?: AcknowledgementState + timestamp?: Date + } + + /** + * @description Stability: UNSTABLE + */ + export interface AcknowledgeWatchRequest extends RequestBase { + watch_id: Id + action_id?: ActionIds + } + + /** + * @description Stability: UNSTABLE + */ + export interface AcknowledgeWatchResponse { + status?: WatchStatus + } + + export interface ActionStatus { + ack?: AcknowledgeState + last_execution?: ExecutionState + last_successful_execution?: ExecutionState + last_throttle?: ThrottleState + } + + export interface ActivationState { + active?: boolean + timestamp?: Date + } + + export interface ExecutionState { + successful?: boolean + timestamp?: Date + } + + export interface ThrottleState { + reason?: string + timestamp?: Date + } + + export interface WatchStatus { + actions?: Record + last_checked?: Date + last_met_condition?: Date + state?: ActivationState + version?: integer + } + + export interface Action { + action_type?: ActionType + condition?: ConditionContainer + foreach?: string + max_iterations?: integer + name?: string + throttle_period?: Time + transform?: TransformContainer + } + + export interface EmailBody { + html?: string + text?: string + } + + export interface PagerDutyContext { + href?: string + src?: string + type?: PagerDutyContextType + } + + export interface PagerDutyEvent { + account?: string + attach_payload?: boolean + client?: string + client_url?: string + context?: PagerDutyContext[] + description?: string + event_type?: PagerDutyEventType + incident_key?: string + } + + export interface SlackAttachment { + author_icon?: string + author_link?: string + author_name?: string + color?: string + fallback?: string + fields?: SlackAttachmentField[] + footer?: string + footer_icon?: string + image_url?: string + pretext?: string + text?: string + thumb_url?: string + title?: string + title_link?: string + ts?: Date + } + + export interface SlackAttachmentField { + short?: boolean + title?: string + value?: string + } + + export interface SlackDynamicAttachment { + attachment_template?: SlackAttachment + list_path?: string + } + + export interface SlackMessage { + attachments?: SlackAttachment[] + dynamic_attachments?: SlackDynamicAttachment + from?: string + icon?: string + text?: string + to?: string[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface ActivateWatchRequest extends RequestBase { + watch_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface ActivateWatchResponse { + status?: ActivationStatus + } + + export interface ActivationStatus { + actions?: Record + state?: ActivationState + } + + export interface AlwaysCondition { + } + + export interface ArrayCompareCondition { + array_path?: string + comparison?: string + path?: string + quantifier?: Quantifier + value?: object + } + + export interface CompareCondition { + comparison?: string + path?: string + value?: object + } + + export interface Condition { + } + + export interface ConditionContainer { + always?: AlwaysCondition + array_compare?: ArrayCompareCondition + compare?: CompareCondition + never?: NeverCondition + script?: ScriptCondition + } + + export interface NeverCondition { + } + + export interface ScriptCondition { + lang?: string + params?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeactivateWatchRequest extends RequestBase { + watch_id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeactivateWatchResponse { + status?: ActivationStatus + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteWatchRequest extends RequestBase { + id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface DeleteWatchResponse { + found?: boolean + _id?: string + _version?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteWatchRequest extends RequestBase { + id?: Id + debug?: boolean + body?: { + action_modes?: Record + alternative_input?: Record + ignore_condition?: boolean + record_execution?: boolean + simulated_actions?: SimulatedActions + trigger_data?: ScheduleTriggerEvent + watch?: Watch + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface ExecuteWatchResponse { + _id?: string + watch_record?: WatchRecord + } + + export interface ExecutionResult { + actions?: ExecutionResultAction[] + condition?: ExecutionResultCondition + execution_duration?: integer + execution_time?: Date + input?: ExecutionResultInput + } + + export interface ExecutionResultAction { + email?: EmailActionResult + id?: string + index?: IndexActionResult + logging?: LoggingActionResult + pagerduty?: PagerDutyActionResult + reason?: string + slack?: SlackActionResult + status?: Status + type?: ActionType + webhook?: WebhookActionResult + } + + export interface ExecutionResultCondition { + met?: boolean + status?: Status + type?: ConditionType + } + + export interface ExecutionResultInput { + payload?: Record + status?: Status + type?: InputType + } + + export interface TriggerEventResult { + manual?: TriggerEventContainer + triggered_time?: Date + type?: string + } + + export interface WatchRecord { + condition?: ConditionContainer + input?: InputContainer + messages?: string[] + metadata?: Record + node?: string + result?: ExecutionResult + state?: ActionExecutionState + trigger_event?: TriggerEventResult + user?: string + watch_id?: string + } + + export interface HttpInputRequestResult extends HttpInputRequest { + } + + export interface HttpInputResponseResult { + body?: string + headers?: Record + status?: integer + } + + export interface SimulatedActions { + actions?: string[] + all?: SimulatedActions + use_all?: boolean + } + + export interface EmailActionResult { + account?: string + message?: EmailResult + reason?: string + } + + export interface EmailResult { + bcc?: string[] + body?: EmailBody + cc?: string[] + from?: string + id?: string + priority?: EmailPriority + reply_to?: string[] + sent_date?: Date + subject?: string + to?: string[] + } + + export interface IndexActionResult { + id?: string + response?: IndexActionResultIndexResponse + } + + /** + * @description Stability: UNSTABLE + */ + export interface IndexActionResultIndexResponse { + created?: boolean + id?: string + index?: IndexName + result?: Result + version?: integer + } + + export interface LoggingActionResult { + logged_text?: string + } + + export interface PagerDutyActionEventResult { + event?: PagerDutyEvent + reason?: string + request?: HttpInputRequestResult + response?: HttpInputResponseResult + } + + export interface PagerDutyActionResult { + sent_event?: PagerDutyActionEventResult + } + + export interface SlackActionMessageResult { + message?: SlackMessage + reason?: string + request?: HttpInputRequestResult + response?: HttpInputResponseResult + status?: Status + to?: string + } + + export interface SlackActionResult { + account?: string + sent_messages?: SlackActionMessageResult[] + } + + export interface WebhookActionResult { + request?: HttpInputRequestResult + response?: HttpInputResponseResult + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetWatchRequest extends RequestBase { + id: Id + } + + /** + * @description Stability: UNSTABLE + */ + export interface GetWatchResponse { + found?: boolean + _id?: string + status?: WatchStatus + watch?: Watch + } + + export interface ChainInput { + inputs?: Record + } + + export interface HttpInput { + extract?: string[] + request?: HttpInputRequest + response_content_type?: ResponseContentType + } + + export interface HttpInputAuthentication { + basic?: HttpInputBasicAuthentication + } + + export interface HttpInputBasicAuthentication { + password?: string + username?: string + } + + export interface HttpInputProxy { + host?: string + port?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface HttpInputRequest { + auth?: HttpInputAuthentication + body?: string + connection_timeout?: Time + headers?: Record + host?: string + method?: HttpInputMethod + params?: Record + path?: string + port?: integer + proxy?: HttpInputProxy + read_timeout?: Time + scheme?: ConnectionScheme + url?: string + } + + export interface IndicesOptions { + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + } + + export interface Input { + } + + export interface InputContainer { + chain?: ChainInput + http?: HttpInput + search?: SearchInput + simple?: SimpleInput + } + + export interface SearchInput { + extract?: string[] + request?: SearchInputRequest + timeout?: Time + } + + /** + * @description Stability: UNSTABLE + */ + export interface SearchInputRequest { + body?: SearchRequest + indices?: IndexName[] + indices_options?: IndicesOptions + search_type?: SearchType + template?: SearchTemplateRequest + } + + export interface SimpleInput { + payload?: Record + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutWatchRequest extends RequestBase { + id: Id + active?: boolean + if_primary_term?: long + if_sequence_number?: long + version?: long + body?: { + actions?: Record + condition?: ConditionContainer + input?: InputContainer + metadata?: Record + throttle_period?: string + transform?: TransformContainer + trigger?: TriggerContainer + } + } + + /** + * @description Stability: UNSTABLE + */ + export interface PutWatchResponse { + created?: boolean + _id?: string + _primary_term?: long + _seq_no?: long + _version?: integer + } + + /** + * @description Stability: UNSTABLE + */ + export interface RestartWatcherResponse extends AcknowledgedResponseBase { + } + + export interface CronExpression extends ScheduleBase { + } + + export interface DailySchedule { + at?: string[] | TimeOfDay + } + + export interface HourlySchedule { + minute?: integer[] + } + + export interface Interval extends ScheduleBase { + factor?: long + unit?: IntervalUnit + } + + export interface Schedule { + } + + export interface ScheduleBase { + } + + export interface ScheduleContainer { + cron?: CronExpression + daily?: DailySchedule + hourly?: HourlySchedule + interval?: Interval + monthly?: TimeOfMonth[] + weekly?: TimeOfWeek[] + yearly?: TimeOfYear[] + } + + export interface ScheduleTriggerEvent { + scheduled_time?: Date | string + triggered_time?: Date | string + } + + export interface TimeOfDay { + hour?: integer[] + minute?: integer[] + } + + export interface TimeOfMonth { + at?: string[] + on?: integer[] + } + + export interface TimeOfWeek { + at?: string[] + on?: Day[] + } + + export interface TimeOfYear { + at?: string[] + int?: Month[] + on?: integer[] + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartWatcherRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StartWatcherResponse extends AcknowledgedResponseBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopWatcherRequest extends RequestBase { + } + + /** + * @description Stability: UNSTABLE + */ + export interface StopWatcherResponse extends AcknowledgedResponseBase { + } + + export interface ChainTransform { + transforms?: TransformContainer[] + } + + export interface ScriptTransform { + lang?: string + params?: Record + } + + export interface SearchTransform { + request?: SearchInputRequest + timeout?: Time + } + + export interface Transform { + } + + export interface TransformContainer { + chain?: ChainTransform + script?: ScriptTransform + search?: SearchTransform + } + + export interface TriggerContainer { + schedule?: ScheduleContainer + } + + export interface TriggerEvent { + } + + export interface TriggerEventContainer { + schedule?: ScheduleTriggerEvent + } + + export interface ExecutionThreadPool { + max_size?: long + queue_size?: long + } + + export interface WatchRecordQueuedStats { + execution_time?: Date + triggered_time?: Date + watch_id?: string + watch_record_id?: string + } + + export interface WatchRecordStats extends WatchRecordQueuedStats { + execution_phase?: ExecutionPhase + } + + export interface WatcherNodeStats { + current_watches?: WatchRecordStats[] + execution_thread_pool?: ExecutionThreadPool + queued_watches?: WatchRecordQueuedStats[] + watch_count?: long + watcher_state?: WatcherState + } + + /** + * @description Stability: UNSTABLE + */ + export interface WatcherStatsRequest extends RequestBase { + metric?: Metrics + emit_stacktraces?: boolean + } + + /** + * @description Stability: UNSTABLE + */ + export interface WatcherStatsResponse { + cluster_name?: string + manually_stopped?: boolean + stats?: WatcherNodeStats[] + } + + export enum MinimumInterval { + second = "second", + minute = "minute", + hour = "hour", + day = "day", + month = "month", + year = "year", + } + + export enum DateInterval { + second = "second", + minute = "minute", + hour = "hour", + day = "day", + week = "week", + month = "month", + quarter = "quarter", + year = "year", + } + + export enum GeoHashPrecision { + Precision1 = "Precision1", + Precision2 = "Precision2", + Precision3 = "Precision3", + Precision4 = "Precision4", + Precision5 = "Precision5", + Precision6 = "Precision6", + Precision7 = "Precision7", + Precision8 = "Precision8", + Precision9 = "Precision9", + Precision10 = "Precision10", + Precision11 = "Precision11", + Precision12 = "Precision12", + } + + export enum GeoTilePrecision { + Precision0 = "Precision0", + Precision1 = "Precision1", + Precision2 = "Precision2", + Precision3 = "Precision3", + Precision4 = "Precision4", + Precision5 = "Precision5", + Precision6 = "Precision6", + Precision7 = "Precision7", + Precision8 = "Precision8", + Precision9 = "Precision9", + Precision10 = "Precision10", + Precision11 = "Precision11", + Precision12 = "Precision12", + Precision13 = "Precision13", + Precision14 = "Precision14", + Precision15 = "Precision15", + Precision16 = "Precision16", + Precision17 = "Precision17", + Precision18 = "Precision18", + Precision19 = "Precision19", + Precision20 = "Precision20", + Precision21 = "Precision21", + Precision22 = "Precision22", + Precision23 = "Precision23", + Precision24 = "Precision24", + Precision25 = "Precision25", + Precision26 = "Precision26", + Precision27 = "Precision27", + Precision28 = "Precision28", + Precision29 = "Precision29", + } + + export enum SamplerAggregationExecutionHint { + map = "map", + global_ordinals = "global_ordinals", + bytes_hash = "bytes_hash", + } + + export enum TermsAggregationCollectMode { + depth_first = "depth_first", + breadth_first = "breadth_first", + } + + export enum TermsAggregationExecutionHint { + map = "map", + global_ordinals = "global_ordinals", + global_ordinals_hash = "global_ordinals_hash", + global_ordinals_low_cardinality = "global_ordinals_low_cardinality", + } + + export enum MatrixStatsMode { + avg = "avg", + min = "min", + max = "max", + sum = "sum", + median = "median", + } + + export enum ValueType { + string = "string", + long = "long", + double = "double", + number = "number", + date = "date", + date_nanos = "date_nanos", + ip = "ip", + numeric = "numeric", + geo_point = "geo_point", + boolean = "boolean", + } + + export enum GapPolicy { + skip = "skip", + insert_zeros = "insert_zeros", + } + + export enum HoltWintersType { + add = "add", + mult = "mult", + } + + export enum AggregationVisitorScope { + Unknown = "Unknown", + Aggregation = "Aggregation", + Bucket = "Bucket", + } + + export enum Language { + Arabic = "Arabic", + Armenian = "Armenian", + Basque = "Basque", + Brazilian = "Brazilian", + Bulgarian = "Bulgarian", + Catalan = "Catalan", + Chinese = "Chinese", + Cjk = "Cjk", + Czech = "Czech", + Danish = "Danish", + Dutch = "Dutch", + English = "English", + Estonian = "Estonian", + Finnish = "Finnish", + French = "French", + Galician = "Galician", + German = "German", + Greek = "Greek", + Hindi = "Hindi", + Hungarian = "Hungarian", + Indonesian = "Indonesian", + Irish = "Irish", + Italian = "Italian", + Latvian = "Latvian", + Norwegian = "Norwegian", + Persian = "Persian", + Portuguese = "Portuguese", + Romanian = "Romanian", + Russian = "Russian", + Sorani = "Sorani", + Spanish = "Spanish", + Swedish = "Swedish", + Turkish = "Turkish", + Thai = "Thai", + } + + export enum SnowballLanguage { + Armenian = "Armenian", + Basque = "Basque", + Catalan = "Catalan", + Danish = "Danish", + Dutch = "Dutch", + English = "English", + Finnish = "Finnish", + French = "French", + German = "German", + German2 = "German2", + Hungarian = "Hungarian", + Italian = "Italian", + Kp = "Kp", + Lovins = "Lovins", + Norwegian = "Norwegian", + Porter = "Porter", + Portuguese = "Portuguese", + Romanian = "Romanian", + Russian = "Russian", + Spanish = "Spanish", + Swedish = "Swedish", + Turkish = "Turkish", + } + + export enum IcuCollationAlternate { + shifted = "shifted", + "non-ignorable" = "non-ignorable", + } + + export enum IcuCollationCaseFirst { + lower = "lower", + upper = "upper", + } + + export enum IcuCollationDecomposition { + no = "no", + identical = "identical", + } + + export enum IcuCollationStrength { + primary = "primary", + secondary = "secondary", + tertiary = "tertiary", + quaternary = "quaternary", + identical = "identical", + } + + export enum IcuNormalizationMode { + decompose = "decompose", + compose = "compose", + } + + export enum IcuNormalizationType { + nfc = "nfc", + nfkc = "nfkc", + nfkc_cf = "nfkc_cf", + } + + export enum IcuTransformDirection { + forward = "forward", + reverse = "reverse", + } + + export enum KuromojiTokenizationMode { + normal = "normal", + search = "search", + extended = "extended", + } + + export enum PhoneticEncoder { + metaphone = "metaphone", + double_metaphone = "double_metaphone", + soundex = "soundex", + refined_soundex = "refined_soundex", + caverphone1 = "caverphone1", + caverphone2 = "caverphone2", + cologne = "cologne", + nysiis = "nysiis", + koelnerphonetik = "koelnerphonetik", + haasephonetik = "haasephonetik", + beider_morse = "beider_morse", + daitch_mokotoff = "daitch_mokotoff", + } + + export enum PhoneticLanguage { + any = "any", + comomon = "comomon", + cyrillic = "cyrillic", + english = "english", + french = "french", + german = "german", + hebrew = "hebrew", + hungarian = "hungarian", + polish = "polish", + romanian = "romanian", + russian = "russian", + spanish = "spanish", + } + + export enum PhoneticNameType { + generic = "generic", + ashkenazi = "ashkenazi", + sephardic = "sephardic", + } + + export enum PhoneticRuleType { + approx = "approx", + exact = "exact", + } + + export enum KeepTypesMode { + include = "include", + exclude = "exclude", + } + + export enum DelimitedPayloadEncoding { + int = "int", + float = "float", + identity = "identity", + } + + export enum EdgeNGramSide { + front = "front", + back = "back", + } + + export enum SynonymFormat { + solr = "solr", + wordnet = "wordnet", + } + + export enum NoriDecompoundMode { + discard = "discard", + none = "none", + mixed = "mixed", + } + + export enum TokenChar { + letter = "letter", + digit = "digit", + whitespace = "whitespace", + punctuation = "punctuation", + symbol = "symbol", + custom = "custom", + } + + export enum ModelCategorizationStatus { + ok = "ok", + warn = "warn", + } + + export enum ModelMemoryStatus { + ok = "ok", + soft_limit = "soft_limit", + hard_limit = "hard_limit", + } + + export enum TransformState { + STARTED = "STARTED", + INDEXING = "INDEXING", + ABORTING = "ABORTING", + STOPPING = "STOPPING", + STOPPED = "STOPPED", + FAILED = "FAILED", + } + + export enum TransformType { + batch = "batch", + continuous = "continuous", + } + + export enum ClusterStatus { + green = "green", + yellow = "yellow", + red = "red", + } + + export enum AllocationExplainDecision { + NO = "NO", + YES = "YES", + THROTTLE = "THROTTLE", + ALWAYS = "ALWAYS", + } + + export enum Decision { + yes = "yes", + no = "no", + worse_balance = "worse_balance", + throttled = "throttled", + awaiting_info = "awaiting_info", + allocation_delayed = "allocation_delayed", + no_valid_shard_copy = "no_valid_shard_copy", + no_attempt = "no_attempt", + } + + export enum StoreCopy { + NONE = "NONE", + AVAILABLE = "AVAILABLE", + CORRUPT = "CORRUPT", + IO_ERROR = "IO_ERROR", + STALE = "STALE", + UNKNOWN = "UNKNOWN", + } + + export enum UnassignedInformationReason { + INDEX_CREATED = "INDEX_CREATED", + CLUSTER_RECOVERED = "CLUSTER_RECOVERED", + INDEX_REOPENED = "INDEX_REOPENED", + DANGLING_INDEX_IMPORTED = "DANGLING_INDEX_IMPORTED", + NEW_INDEX_RESTORED = "NEW_INDEX_RESTORED", + EXISTING_INDEX_RESTORED = "EXISTING_INDEX_RESTORED", + REPLICA_ADDED = "REPLICA_ADDED", + ALLOCATION_FAILED = "ALLOCATION_FAILED", + NODE_LEFT = "NODE_LEFT", + REROUTE_CANCELLED = "REROUTE_CANCELLED", + REINITIALIZED = "REINITIALIZED", + REALLOCATED_REPLICA = "REALLOCATED_REPLICA", + PRIMARY_FAILED = "PRIMARY_FAILED", + FORCED_EMPTY_PRIMARY = "FORCED_EMPTY_PRIMARY", + MANUAL_ALLOCATION = "MANUAL_ALLOCATION", + } + + export enum NodeRole { + master = "master", + data = "data", + client = "client", + ingest = "ingest", + ml = "ml", + voting_only = "voting_only", + transform = "transform", + remote_cluster_client = "remote_cluster_client", + coordinating_only = "coordinating_only", + } + + export enum Bytes { + b = "b", + k = "k", + kb = "kb", + m = "m", + mb = "mb", + g = "g", + gb = "gb", + t = "t", + tb = "tb", + p = "p", + pb = "pb", + } + + export enum Conflicts { + abort = "abort", + proceed = "proceed", + } + + export enum DefaultOperator { + AND = "AND", + OR = "OR", + } + + export enum ExpandWildcards { + open = "open", + closed = "closed", + hidden = "hidden", + none = "none", + all = "all", + } + + export enum GroupBy { + nodes = "nodes", + parents = "parents", + none = "none", + } + + export enum Health { + green = "green", + yellow = "yellow", + red = "red", + } + + export enum HttpMethod { + GET = "GET", + POST = "POST", + PUT = "PUT", + DELETE = "DELETE", + HEAD = "HEAD", + } + + export enum Level { + cluster = "cluster", + indices = "indices", + shards = "shards", + } + + export enum OpType { + index = "index", + create = "create", + } + + export enum PipelineFailure { + BadAuthentication = "BadAuthentication", + BadResponse = "BadResponse", + PingFailure = "PingFailure", + SniffFailure = "SniffFailure", + CouldNotStartSniffOnStartup = "CouldNotStartSniffOnStartup", + MaxTimeoutReached = "MaxTimeoutReached", + MaxRetriesReached = "MaxRetriesReached", + Unexpected = "Unexpected", + BadRequest = "BadRequest", + NoNodesAttempted = "NoNodesAttempted", + } + + export enum Refresh { + true = "true", + false = "false", + wait_for = "wait_for", + } + + export enum SearchType { + query_then_fetch = "query_then_fetch", + dfs_query_then_fetch = "dfs_query_then_fetch", + } + + export enum Size { + Raw = "Raw", + k = "k", + m = "m", + g = "g", + t = "t", + p = "p", + } + + export enum SuggestMode { + missing = "missing", + popular = "popular", + always = "always", + } + + export enum ThreadType { + cpu = "cpu", + wait = "wait", + block = "block", + } + + export enum VersionType { + internal = "internal", + external = "external", + external_gte = "external_gte", + force = "force", + } + + export enum WaitForEvents { + immediate = "immediate", + urgent = "urgent", + high = "high", + normal = "normal", + low = "low", + languid = "languid", + } + + export enum WaitForStatus { + green = "green", + yellow = "yellow", + red = "red", + } + + export enum DateMathOperation { + "+" = "+", + "-" = "-", + } + + export enum DateMathTimeUnit { + Second = "s", + Minute = "m", + Hour = "h", + Day = "d", + Week = "w", + Month = "M", + Year = "y", + } + + export enum DistanceUnit { + in = "in", + ft = "ft", + yd = "yd", + mi = "mi", + nmi = "nmi", + km = "km", + m = "m", + cm = "cm", + mm = "mm", + } + + export enum GeoDistanceType { + arc = "arc", + plane = "plane", + } + + export enum GeoShapeRelation { + intersects = "intersects", + disjoint = "disjoint", + within = "within", + contains = "contains", + } + + export enum ShapeRelation { + intersects = "intersects", + disjoint = "disjoint", + within = "within", + } + + export enum TimeUnit { + nanos = "nanos", + micros = "micros", + ms = "ms", + s = "s", + m = "m", + h = "h", + d = "d", + } + + export enum Result { + Error = "Error", + created = "created", + updated = "updated", + deleted = "deleted", + not_found = "not_found", + noop = "noop", + } + + export enum RecoveryInitialShards { + quorem = "quorem", + "quorem-1" = "quorem-1", + full = "full", + "full-1" = "full-1", + } + + export enum LogLevel { + error = "error", + warn = "warn", + info = "info", + debug = "debug", + trace = "trace", + } + + export enum IndexSortMissing { + _first = "_first", + _last = "_last", + } + + export enum IndexSortMode { + min = "min", + max = "max", + } + + export enum IndexSortOrder { + asc = "asc", + desc = "desc", + } + + export enum FileSystemStorageImplementation { + simplefs = "simplefs", + niofs = "niofs", + mmapfs = "mmapfs", + default_fs = "default_fs", + } + + export enum TranslogDurability { + request = "request", + async = "async", + } + + export enum Normalization { + no = "no", + h1 = "h1", + h2 = "h2", + h3 = "h3", + z = "z", + } + + export enum DFIIndependenceMeasure { + standardized = "standardized", + saturated = "saturated", + chisquared = "chisquared", + } + + export enum DFRAfterEffect { + no = "no", + b = "b", + l = "l", + } + + export enum DFRBasicModel { + be = "be", + d = "d", + g = "g", + if = "if", + in = "in", + ine = "ine", + p = "p", + } + + export enum IBDistribution { + ll = "ll", + spl = "spl", + } + + export enum IBLambda { + df = "df", + ttf = "ttf", + } + + export enum ShardStoreAllocation { + primary = "primary", + replica = "replica", + unused = "unused", + } + + export enum ShardRoutingState { + UNASSIGNED = "UNASSIGNED", + INITIALIZING = "INITIALIZING", + STARTED = "STARTED", + RELOCATING = "RELOCATING", + } + + export enum ConvertProcessorType { + integer = "integer", + long = "long", + float = "float", + double = "double", + string = "string", + boolean = "boolean", + auto = "auto", + } + + export enum DateRounding { + s = "s", + m = "m", + h = "h", + d = "d", + w = "w", + M = "M", + y = "y", + } + + export enum ShapeType { + geo_shape = "geo_shape", + shape = "shape", + } + + export enum UserAgentProperty { + NAME = "NAME", + MAJOR = "MAJOR", + MINOR = "MINOR", + PATCH = "PATCH", + OS = "OS", + OS_NAME = "OS_NAME", + OS_MAJOR = "OS_MAJOR", + OS_MINOR = "OS_MINOR", + DEVICE = "DEVICE", + BUILD = "BUILD", + } + + export enum DynamicMapping { + strict = "strict", + } + + export enum TermVectorOption { + no = "no", + yes = "yes", + with_offsets = "with_offsets", + with_positions = "with_positions", + with_positions_offsets = "with_positions_offsets", + with_positions_offsets_payloads = "with_positions_offsets_payloads", + } + + export enum MatchType { + simple = "simple", + regex = "regex", + } + + export enum FieldType { + none = "none", + geo_point = "geo_point", + geo_shape = "geo_shape", + ip = "ip", + binary = "binary", + keyword = "keyword", + text = "text", + search_as_you_type = "search_as_you_type", + date = "date", + date_nanos = "date_nanos", + boolean = "boolean", + completion = "completion", + nested = "nested", + object = "object", + murmur3 = "murmur3", + token_count = "token_count", + percolator = "percolator", + integer = "integer", + long = "long", + short = "short", + byte = "byte", + float = "float", + half_float = "half_float", + scaled_float = "scaled_float", + double = "double", + integer_range = "integer_range", + float_range = "float_range", + long_range = "long_range", + double_range = "double_range", + date_range = "date_range", + ip_range = "ip_range", + alias = "alias", + join = "join", + rank_feature = "rank_feature", + rank_features = "rank_features", + flattened = "flattened", + shape = "shape", + histogram = "histogram", + constant_keyword = "constant_keyword", + } + + export enum NumberType { + float = "float", + half_float = "half_float", + scaled_float = "scaled_float", + double = "double", + integer = "integer", + long = "long", + short = "short", + byte = "byte", + } + + export enum RangeType { + integer_range = "integer_range", + float_range = "float_range", + long_range = "long_range", + double_range = "double_range", + date_range = "date_range", + ip_range = "ip_range", + } + + export enum IndexOptions { + docs = "docs", + freqs = "freqs", + positions = "positions", + offsets = "offsets", + } + + export enum GeoOrientation { + ClockWise = "ClockWise", + CounterClockWise = "CounterClockWise", + } + + export enum GeoStrategy { + recursive = "recursive", + term = "term", + } + + export enum GeoTree { + geohash = "geohash", + quadtree = "quadtree", + } + + export enum ShapeOrientation { + ClockWise = "ClockWise", + CounterClockWise = "CounterClockWise", + } + + export enum AllocationEnable { + all = "all", + primaries = "primaries", + new_primaries = "new_primaries", + none = "none", + } + + export enum AllowRebalance { + always = "always", + indices_primaries_active = "indices_primaries_active", + indices_all_active = "indices_all_active", + } + + export enum RebalanceEnable { + all = "all", + primaries = "primaries", + replicas = "replicas", + none = "none", + } + + export enum FielddataLoading { + eager = "eager", + eager_global_ordinals = "eager_global_ordinals", + } + + export enum GeoPointFielddataFormat { + array = "array", + doc_values = "doc_values", + compressed = "compressed", + disabled = "disabled", + } + + export enum NumericFielddataFormat { + array = "array", + disabled = "disabled", + } + + export enum StringFielddataFormat { + paged_bytes = "paged_bytes", + disabled = "disabled", + } + + export enum ScriptLang { + painless = "painless", + expression = "expression", + mustache = "mustache", + } + + export enum Operator { + and = "and", + or = "or", + } + + export enum FunctionBoostMode { + multiply = "multiply", + replace = "replace", + sum = "sum", + avg = "avg", + max = "max", + min = "min", + } + + export enum FunctionScoreMode { + multiply = "multiply", + sum = "sum", + avg = "avg", + first = "first", + max = "max", + min = "min", + } + + export enum MultiValueMode { + min = "min", + max = "max", + avg = "avg", + sum = "sum", + } + + export enum FieldValueFactorModifier { + none = "none", + log = "log", + log1p = "log1p", + log2p = "log2p", + ln = "ln", + ln1p = "ln1p", + ln2p = "ln2p", + square = "square", + sqrt = "sqrt", + reciprocal = "reciprocal", + } + + export enum TextQueryType { + best_fields = "best_fields", + most_fields = "most_fields", + cross_fields = "cross_fields", + phrase = "phrase", + phrase_prefix = "phrase_prefix", + bool_prefix = "bool_prefix", + } + + export enum ZeroTermsQuery { + all = "all", + none = "none", + } + + export enum SimpleQueryStringFlags { + NONE = "NONE", + AND = "AND", + OR = "OR", + NOT = "NOT", + PREFIX = "PREFIX", + PHRASE = "PHRASE", + PRECEDENCE = "PRECEDENCE", + ESCAPE = "ESCAPE", + WHITESPACE = "WHITESPACE", + FUZZY = "FUZZY", + NEAR = "NEAR", + SLOP = "SLOP", + ALL = "ALL", + } + + export enum GeoValidationMethod { + coerce = "coerce", + ignore_malformed = "ignore_malformed", + strict = "strict", + } + + export enum GeoExecution { + memory = "memory", + indexed = "indexed", + } + + export enum GeoFormat { + GeoJson = "GeoJson", + WellKnownText = "WellKnownText", + } + + export enum CharacterType { + Whitespace = "Whitespace", + Alpha = "Alpha", + Comment = "Comment", + } + + export enum TokenType { + None = "None", + Word = "Word", + LParen = "LParen", + RParen = "RParen", + Comma = "Comma", + } + + export enum ChildScoreMode { + none = "none", + avg = "avg", + sum = "sum", + max = "max", + min = "min", + } + + export enum NestedScoreMode { + avg = "avg", + sum = "sum", + min = "min", + max = "max", + none = "none", + } + + export enum RewriteMultiTerm { + constant_score = "constant_score", + scoring_boolean = "scoring_boolean", + constant_score_boolean = "constant_score_boolean", + top_terms_N = "top_terms_N", + top_terms_boost_N = "top_terms_boost_N", + top_terms_blended_freqs_N = "top_terms_blended_freqs_N", + } + + export enum RangeRelation { + within = "within", + contains = "contains", + intersects = "intersects", + } + + export enum VisitorScope { + Unknown = "Unknown", + Query = "Query", + Filter = "Filter", + Must = "Must", + MustNot = "MustNot", + Should = "Should", + PositiveQuery = "PositiveQuery", + NegativeQuery = "NegativeQuery", + Span = "Span", + } + + export enum BoundaryScanner { + chars = "chars", + sentence = "sentence", + word = "word", + } + + export enum HighlighterEncoder { + default = "default", + html = "html", + } + + export enum HighlighterFragmenter { + simple = "simple", + span = "span", + } + + export enum HighlighterOrder { + score = "score", + } + + export enum HighlighterTagsSchema { + styled = "styled", + } + + export enum HighlighterType { + plain = "plain", + fvh = "fvh", + unified = "unified", + } + + export enum TotalHitsRelation { + eq = "eq", + gte = "gte", + } + + export enum ScoreMode { + avg = "avg", + max = "max", + min = "min", + multiply = "multiply", + total = "total", + } + + export enum NumericType { + long = "long", + double = "double", + date = "date", + date_nanos = "date_nanos", + } + + export enum SortMode { + min = "min", + max = "max", + sum = "sum", + avg = "avg", + median = "median", + } + + export enum SortOrder { + asc = "asc", + desc = "desc", + } + + export enum SortSpecialField { + _score = "_score", + _doc = "_doc", + } + + export enum StringDistance { + internal = "internal", + damerau_levenshtein = "damerau_levenshtein", + levenshtein = "levenshtein", + jaro_winkler = "jaro_winkler", + ngram = "ngram", + } + + export enum SuggestSort { + score = "score", + frequency = "frequency", + } + + export enum FollowerIndexStatus { + active = "active", + paused = "paused", + } + + export enum EnrichPolicyPhase { + SCHEDULED = "SCHEDULED", + RUNNING = "RUNNING", + COMPLETE = "COMPLETE", + FAILED = "FAILED", + } + + export enum LifecycleOperationMode { + RUNNING = "RUNNING", + STOPPING = "STOPPING", + STOPPED = "STOPPED", + } + + export enum LicenseStatus { + active = "active", + valid = "valid", + invalid = "invalid", + expired = "expired", + } + + export enum LicenseType { + missing = "missing", + trial = "trial", + basic = "basic", + standard = "standard", + dev = "dev", + silver = "silver", + gold = "gold", + platinum = "platinum", + enterprise = "enterprise", + } + + export enum ChunkingMode { + auto = "auto", + manual = "manual", + off = "off", + } + + export enum DatafeedState { + started = "started", + stopped = "stopped", + starting = "starting", + stopping = "stopping", + } + + export enum JobState { + closing = "closing", + closed = "closed", + opened = "opened", + failed = "failed", + opening = "opening", + } + + export enum MemoryStatus { + ok = "ok", + soft_limit = "soft_limit", + hard_limit = "hard_limit", + } + + export enum AppliesTo { + actual = "actual", + typical = "typical", + diff_from_typical = "diff_from_typical", + time = "time", + } + + export enum ConditionOperator { + gt = "gt", + gte = "gte", + lt = "lt", + lte = "lte", + } + + export enum CountFunction { + Count = "Count", + HighCount = "HighCount", + LowCount = "LowCount", + } + + export enum DistinctCountFunction { + DistinctCount = "DistinctCount", + LowDistinctCount = "LowDistinctCount", + HighDistinctCount = "HighDistinctCount", + } + + export enum GeographicFunction { + LatLong = "LatLong", + } + + export enum InfoContentFunction { + InfoContent = "InfoContent", + HighInfoContent = "HighInfoContent", + LowInfoContent = "LowInfoContent", + } + + export enum MetricFunction { + Min = "Min", + Max = "Max", + Median = "Median", + HighMedian = "HighMedian", + LowMedian = "LowMedian", + Mean = "Mean", + HighMean = "HighMean", + LowMean = "LowMean", + Metric = "Metric", + Varp = "Varp", + HighVarp = "HighVarp", + LowVarp = "LowVarp", + } + + export enum NonNullSumFunction { + NonNullSum = "NonNullSum", + HighNonNullSum = "HighNonNullSum", + LowNonNullSum = "LowNonNullSum", + } + + export enum NonZeroCountFunction { + NonZeroCount = "NonZeroCount", + LowNonZeroCount = "LowNonZeroCount", + HighNonZeroCount = "HighNonZeroCount", + } + + export enum RareFunction { + Rare = "Rare", + FreqRare = "FreqRare", + } + + export enum RuleAction { + skip_result = "skip_result", + skip_model_update = "skip_model_update", + } + + export enum RuleFilterType { + include = "include", + exclude = "exclude", + } + + export enum SumFunction { + Sum = "Sum", + HighSum = "HighSum", + LowSum = "LowSum", + } + + export enum TimeFunction { + TimeOfDay = "TimeOfDay", + TimeOfWeek = "TimeOfWeek", + } + + export enum ExcludeFrequent { + all = "all", + none = "none", + by = "by", + over = "over", + } + + export enum DeprecationWarningLevel { + none = "none", + info = "info", + warning = "warning", + critical = "critical", + } + + export enum IndexingJobState { + started = "started", + indexing = "indexing", + stopping = "stopping", + stopped = "stopped", + aborting = "aborting", + } + + export enum RollupMetric { + min = "min", + max = "max", + sum = "sum", + avg = "avg", + value_count = "value_count", + } + + export enum AccessTokenGrantType { + password = "password", + } + + export enum AcknowledgementState { + awaits_successful_execution = "awaits_successful_execution", + ackable = "ackable", + acked = "acked", + } + + export enum ActionType { + email = "email", + webhook = "webhook", + index = "index", + logging = "logging", + slack = "slack", + pagerduty = "pagerduty", + } + + export enum DataAttachmentFormat { + json = "json", + yaml = "yaml", + } + + export enum EmailPriority { + lowest = "lowest", + low = "low", + normal = "normal", + high = "high", + highest = "highest", + } + + export enum PagerDutyContextType { + link = "link", + image = "image", + } + + export enum PagerDutyEventType { + trigger = "trigger", + resolve = "resolve", + acknowledge = "acknowledge", + } + + export enum ConditionType { + always = "always", + never = "never", + script = "script", + compare = "compare", + array_compare = "array_compare", + } + + export enum Quantifier { + some = "some", + all = "all", + } + + export enum ActionExecutionState { + awaits_execution = "awaits_execution", + checking = "checking", + execution_not_needed = "execution_not_needed", + throttled = "throttled", + executed = "executed", + failed = "failed", + deleted_while_queued = "deleted_while_queued", + not_executed_already_queued = "not_executed_already_queued", + } + + export enum ActionExecutionMode { + simulate = "simulate", + force_simulate = "force_simulate", + execute = "execute", + force_execute = "force_execute", + skip = "skip", + } + + export enum Status { + success = "success", + failure = "failure", + simulated = "simulated", + throttled = "throttled", + } + + export enum ConnectionScheme { + http = "http", + https = "https", + } + + export enum HttpInputMethod { + head = "head", + get = "get", + post = "post", + put = "put", + delete = "delete", + } + + export enum InputType { + http = "http", + search = "search", + simple = "simple", + } + + export enum ResponseContentType { + json = "json", + yaml = "yaml", + text = "text", + } + + export enum Day { + sunday = "sunday", + monday = "monday", + tuesday = "tuesday", + wednesday = "wednesday", + thursday = "thursday", + friday = "friday", + saturday = "saturday", + } + + export enum IntervalUnit { + s = "s", + m = "m", + h = "h", + d = "d", + w = "w", + } + + export enum Month { + january = "january", + february = "february", + march = "march", + april = "april", + may = "may", + june = "june", + july = "july", + august = "august", + september = "september", + october = "october", + november = "november", + december = "december", + } + + export enum ExecutionPhase { + awaits_execution = "awaits_execution", + started = "started", + input = "input", + condition = "condition", + actions = "actions", + watch_transform = "watch_transform", + aborted = "aborted", + finished = "finished", + } + + export enum WatcherState { + stopped = "stopped", + starting = "starting", + started = "started", + stopping = "stopping", + } +} + +export default T diff --git a/dsl/src/fluent.ts b/dsl/src/fluent.ts index 2eeb75546..e3375d3e9 100644 --- a/dsl/src/fluent.ts +++ b/dsl/src/fluent.ts @@ -27,6 +27,7 @@ import Q from './query' import A from './aggregation' import * as t from './types' +import T from '../es-types' const kState = Symbol('dsl-query-state') @@ -55,9 +56,11 @@ class FluentQ { return Q.compile(this.build()) } - match (key: string, val: string | Symbol, opts?: Record): this - match (key: string, val: string[], opts?: Record): this - match (key: string, val: any, opts?: Record): this { + match (key: string, val: string | Symbol): this + match (key: string, val: string | Symbol, opts: T.MatchQuery): this + match (key: string, val: (string | Symbol)[]): this + match (key: string, val: (string | Symbol)[], opts: T.MatchQuery): this + match (key: string, val: any, opts?: any): this { this[kState].push(Q.match(key, val, opts)) return this } @@ -166,7 +169,7 @@ class FluentQ { return this } - ids (key: string, val: string[] | Symbol, opts: Record): this { + ids (key: string, val: string[] | Symbol, opts: T.IdsQuery): this { this[kState].push(Q.ids(key, val, opts)) return this } @@ -231,7 +234,7 @@ class FluentQ { return this } - disMax (queries: t.AnyQuery[], opts?: Record): this { + disMax (queries: Record[], opts?: Record): this { this[kState].push(Q.disMax(queries, opts)) return this } diff --git a/dsl/src/query.ts b/dsl/src/query.ts index d9b9acacc..2617562c9 100644 --- a/dsl/src/query.ts +++ b/dsl/src/query.ts @@ -24,8 +24,12 @@ /* eslint no-inner-declarations: 0 */ import * as t from './types' +import T from '../es-types' -function Q (...blocks: t.AnyQuery[]): Record { +type SearchRequest = Required['body'] +type BoolBlock = { bool: T.BoolQuery } +type QueryBlock = { query: T.QueryContainer } +function Q (...blocks: (SearchRequest | T.QueryContainer)[]): SearchRequest { blocks = blocks.flat() const topLevelKeys = [ 'aggs', @@ -51,10 +55,23 @@ function Q (...blocks: t.AnyQuery[]): Record { 'version' ] - const queries = blocks.filter(block => !topLevelKeys.includes(Object.keys(block)[0])) - const body: Record = queries.length === 1 && !isClause(queries[0]) - ? isQuery(queries[0]) ? queries[0] : { query: queries[0] } - : queries.length > 0 ? Q.bool(...queries) : {} + // @ts-ignore + const queries: (T.QueryContainer | T.BoolQuery)[] = blocks.filter(block => !topLevelKeys.includes(Object.keys(block)[0])) + + let body: SearchRequest + if (queries.length === 1 && !isBoolQuery(queries[0])) { + if (isQuery(queries[0])) { + body = queries[0] + } else { + body = { query: queries[0] } + } + } else { + if (queries.length > 0) { + body = { query: Q.bool(...queries) } + } else { + body = {} + } + } for (const block of blocks) { const key = Object.keys(block)[0] if (topLevelKeys.includes(key)) { @@ -168,20 +185,35 @@ namespace Q { } } } + + // type MatchContainer = { match: Record } + export function match (key: string, val: string | Symbol): { match: Record } + export function match (key: string, val: string | Symbol, opts: T.MatchQuery): { match: T.MatchQuery } + export function match (key: string, val: (string | Symbol)[]): { match: Record }[] + export function match (key: string, val: (string | Symbol)[], opts: T.MatchQuery): { match: T.MatchQuery }[] + export function match (key: string, val: any, opts?: T.MatchQuery): any { return generateQueryObject('match', key, val, opts) } - export function matchPhrase (key: string, val: string | Symbol, opts?: Record): t.Condition { + type MatchPhraseContainer = { match_phrase: Record } + export function matchPhrase (key: string, val: string | Symbol, opts?: T.MatchPhraseQuery): MatchPhraseContainer + export function matchPhrase (key: string, val: string[], opts?: T.MatchPhraseQuery): MatchPhraseContainer[] + export function matchPhrase (key: string, val: any, opts?: T.MatchPhraseQuery): any { return generateQueryObject('match_phrase', key, val, opts) } - export function matchPhrasePrefix (key: string, val: string | Symbol, opts?: Record): t.Condition { + type MatchPhrasePrefixContainer = { match_phrase_prefix: Record } + export function matchPhrasePrefix (key: string, val: string | Symbol, opts?: T.MatchPhrasePrefixQuery): MatchPhrasePrefixContainer + export function matchPhrasePrefix (key: string, val: string[], opts?: T.MatchPhrasePrefixQuery): MatchPhrasePrefixContainer[] + export function matchPhrasePrefix (key: string, val: any, opts?: T.MatchPhrasePrefixQuery): any { return generateQueryObject('match_phrase_prefix', key, val, opts) } - export function multiMatch (keys: string[], val: string | Symbol, opts?: Record): t.Condition { + type MultiMatchContainer = { multi_match: T.MultiMatchQuery } + export function multiMatch (keys: string[], val: string | Symbol, opts?: T.MultiMatchQuery): MultiMatchContainer { return { multi_match: { + // @ts-expect-error query: val, fields: keys, ...opts @@ -189,46 +221,57 @@ namespace Q { } } - export function matchAll (opts?: Record): t.Condition { + type MatchAllContainer = { match_all: T.MatchAllQuery } + export function matchAll (opts?: T.MatchAllQuery): MatchAllContainer { return { match_all: { ...opts } } } - export function matchNone (): t.Condition { + type MatchNoneContainer = { match_none: {} } + export function matchNone (): MatchNoneContainer { return { match_none: {} } } - export function common (key: string, val: string | Symbol, opts: Record): t.Condition { + type CommonContainer = { common: Record } + export function common (key: string, val: string | Symbol, opts: T.CommonTermsQuery): CommonContainer + export function common (key: string, val: string[], opts: T.CommonTermsQuery): CommonContainer[] + export function common (key: string, val: any, opts: T.CommonTermsQuery): any { return generateQueryObject('common', key, val, opts) } - export function queryString (val: string | Symbol, opts: Record): t.Condition { + type QueryStringContainer = { query_string: T.QueryStringQuery } + export function queryString (val: string | Symbol, opts: T.QueryStringQuery): QueryStringContainer { return { query_string: { + // @ts-expect-error query: val, ...opts } } } - export function simpleQueryString (val: string | Symbol, opts: Record): t.Condition { + type SimpleQueryStringContainer = { simple_query_string: T.SimpleQueryStringQuery } + export function simpleQueryString (val: string | Symbol, opts: T.SimpleQueryStringQuery): SimpleQueryStringContainer { return { simple_query_string: { + // @ts-expect-error query: val, ...opts } } } - export function term (key: string, val: string | Symbol, opts?: Record): t.Condition - export function term (key: string, val: string[], opts?: Record): t.Condition - export function term (key: string, val: any, opts?: Record): t.Condition { + type TermContainer = { term: Record } + export function term (key: string, val: string | Symbol, opts?: T.TermQuery): TermContainer + export function term (key: string, val: string[], opts?: T.TermQuery): TermsContainer + export function term (key: string, val: any, opts?: Record): any { if (Array.isArray(val)) { return Q.terms(key, val, opts) } return generateValueObject('term', key, val, opts) } - export function terms (key: string, val: string[] | Symbol, opts?: Record): t.Condition { + type TermsContainer = { terms: T.TermsQuery } + export function terms (key: string, val: string[] | Symbol, opts?: T.TermsQuery): TermsContainer { return { terms: { [key]: val, @@ -237,7 +280,8 @@ namespace Q { } } - export function termsSet (key: string, val: string[] | Symbol, opts: Record): t.Condition { + type TermsSetContainer = { terms_set: T.TermsSetQuery } + export function termsSet (key: string, val: string[] | Symbol, opts: T.TermsSetQuery): TermsSetContainer { return { terms_set: { [key]: { @@ -248,45 +292,53 @@ namespace Q { } } - export function range (key: string, val: any): t.Condition { + type RangeContainer = { range: T.RangeQuery } + export function range (key: string, val: T.RangeQuery): RangeContainer { return { range: { [key]: val } } } - export function exists (key: string): t.Condition - export function exists (key: string[]): t.Condition[] - export function exists (key: any): t.Condition | t.Condition[] { + type ExistContainer = { exists: T.ExistsQuery } + export function exists (key: string): ExistContainer + export function exists (key: string[]): ExistContainer[] + export function exists (key: any): any { if (Array.isArray(key)) { return key.map(k => exists(k)) } return { exists: { field: key } } } - export function prefix (key: string, val: string | Symbol, opts?: Record): t.Condition - export function prefix (key: string, val: string[], opts?: Record): t.Condition[] - export function prefix (key: string, val: any, opts?: Record): t.Condition | t.Condition[] { + type PrefixContainer = { prefix: Record } + export function prefix (key: string, val: string | Symbol, opts?: T.PrefixQuery): PrefixContainer + export function prefix (key: string, val: string[], opts?: T.PrefixQuery): PrefixContainer[] + export function prefix (key: string, val: any, opts?: T.PrefixQuery): any { return generateValueObject('prefix', key, val, opts) } - export function wildcard (key: string, val: string | Symbol, opts?: Record): t.Condition - export function wildcard (key: string, val: string[], opts?: Record): t.Condition[] - export function wildcard (key: string, val: any, opts?: Record): t.Condition | t.Condition[] { + type WildcardContainer = { wildcard: Record } + export function wildcard (key: string, val: string | Symbol, opts?: T.WildcardQuery): WildcardContainer + export function wildcard (key: string, val: string[], opts?: T.WildcardQuery): WildcardContainer[] + export function wildcard (key: string, val: any, opts?: T.WildcardQuery): any { return generateValueObject('wildcard', key, val, opts) } - export function regexp (key: string, val: string | Symbol, opts?: Record): t.Condition - export function regexp (key: string, val: string[], opts?: Record): t.Condition[] - export function regexp (key: string, val: any, opts?: Record): t.Condition | t.Condition[] { + type RegExpContainer = { regexp: Record } + export function regexp (key: string, val: string | Symbol, opts?: T.RegexpQuery): RegExpContainer + export function regexp (key: string, val: string[], opts?: T.RegexpQuery): RegExpContainer[] + export function regexp (key: string, val: any, opts?: T.RegexpQuery): any { return generateValueObject('regexp', key, val, opts) } - export function fuzzy (key: string, val: string | Symbol, opts?: Record): t.Condition - export function fuzzy (key: string, val: string[], opts?: Record): t.Condition[] - export function fuzzy (key: string, val: any, opts?: Record): t.Condition | t.Condition[] { + type FuzzyContainer = { fuzzy: Record } + export function fuzzy (key: string, val: string | Symbol, opts?: T.FuzzyQuery): FuzzyContainer + export function fuzzy (key: string, val: string[], opts?: T.FuzzyQuery): FuzzyContainer[] + export function fuzzy (key: string, val: any, opts?: T.FuzzyQuery): any { return generateValueObject('fuzzy', key, val, opts) } - export function ids (key: string, val: string[] | Symbol, opts: Record): t.Condition { + type IdsContainer = { ids: Record } + export function ids (key: string, val: string[] | Symbol, opts: T.IdsQuery): IdsContainer { return { + // @ts-expect-error ids: { [key]: { values: val, @@ -296,30 +348,36 @@ namespace Q { } } - export function must (...queries: t.AnyQuery[]): t.MustClause { + type AnyQueryWithArray = T.QueryContainer | T.BoolQuery | T.QueryContainer[] | T.BoolQuery[] + type AnyQuery = T.QueryContainer | T.BoolQuery + export function must (...queries: AnyQueryWithArray[]): { must: T.QueryContainer[] } { + // @ts-ignore return { must: queries.flatMap(mergeableMust) } } - export function should (...queries: t.AnyQuery[]): t.ShouldClause { + export function should (...queries: AnyQueryWithArray[]): { should: T.QueryContainer[] } { + // @ts-ignore return { should: queries.flatMap(mergeableShould) } } - export function mustNot (...queries: t.AnyQuery[]): t.MustNotClause { + export function mustNot (...queries: AnyQueryWithArray[]): { must_not: T.QueryContainer[] } { + // @ts-ignore return { must_not: queries.flatMap(mergeableMustNot) } } - export function filter (...queries: t.AnyQuery[]): t.FilterClause { + export function filter (...queries: AnyQueryWithArray[]): { filter: T.QueryContainer[] } { + // @ts-ignore return { filter: queries.flatMap(mergeableFilter) } } - export function bool (...queries: t.AnyBoolQuery[]): t.BoolQuery { + export function bool (...queries: (T.QueryContainer | T.BoolQuery)[]): BoolBlock { if (queries.length === 0) { - return { query: { bool: {} } } + return { bool: {} } } // @ts-expect-error const defaultClause = queries.find(q => q && !!q.minimum_should_match) ? 'should' : 'must' - const normalizedQueries: t.BoolQueryOptions[] = queries + const normalizedQueries = queries .flat() .filter(val => { // filters empty objects/arrays as well @@ -328,13 +386,13 @@ namespace Q { } return !!val }) - .map(q => toClause(q, defaultClause)) + .map(q => toBoolQuery(q, defaultClause)) - const mustClauses: t.AnyQuery[] = [] - const mustNotClauses: t.AnyQuery[] = [] - const shouldClauses: t.AnyQuery[] = [] - const filterClauses: t.AnyQuery[] = [] - let minimum_should_match: number | null = null + const mustClauses: T.QueryContainer[] = [] + const mustNotClauses: T.QueryContainer[] = [] + const shouldClauses: T.QueryContainer[] = [] + const filterClauses: T.QueryContainer[] = [] + let minimum_should_match: number | string | null = null let _name: string | null = null for (const query of normalizedQueries) { @@ -373,33 +431,31 @@ namespace Q { } return { - query: { - bool: booptimize({ - ...(mustClauses.length && Q.must(...mustClauses)), - ...(mustNotClauses.length && Q.mustNot(...mustNotClauses)), - ...(shouldClauses.length && Q.should(...shouldClauses)), - ...(filterClauses.length && Q.filter(...filterClauses)), - ...(_name && { _name }), - ...(minimum_should_match && { minimum_should_match }) - }) - } + bool: booptimize({ + ...(mustClauses.length && Q.must(...mustClauses)), + ...(mustNotClauses.length && Q.mustNot(...mustNotClauses)), + ...(shouldClauses.length && Q.should(...shouldClauses)), + ...(filterClauses.length && Q.filter(...filterClauses)), + ...(_name && { _name }), + ...(minimum_should_match && { minimum_should_match }) + }) } } - export function and (...queries: t.AnyBoolQuery[]): t.BoolQuery { + export function and (...queries: AnyQuery[]): BoolBlock { let query = queries[0] for (let i = 1; i < queries.length; i++) { query = andOp(query, queries[i]) } - return { query: toBoolBlock(query) } + return toBoolBlock(query) - function andOp (q1: t.AnyBoolQuery, q2: t.AnyBoolQuery): t.BoolBlock { - const b1: t.BoolQueryOptions = toClause(q1) - const b2: t.BoolQueryOptions = toClause(q2) + function andOp (q1: AnyQuery, q2: AnyQuery): BoolBlock { + const b1 = toBoolQuery(q1) + const b2 = toBoolQuery(q2) if (b1.should == null && b2.should == null) { - const mustClauses: t.AnyQuery[] = (b1.must || []).concat(b2.must || []) - const mustNotClauses: t.AnyQuery[] = (b1.must_not || []).concat(b2.must_not || []) - const filterClauses: t.AnyQuery[] = (b1.filter || []).concat(b2.filter || []) + const mustClauses: T.QueryContainer[] = (b1.must || []).concat(b2.must || []) + const mustNotClauses: T.QueryContainer[] = (b1.must_not || []).concat(b2.must_not || []) + const filterClauses: T.QueryContainer[] = (b1.filter || []).concat(b2.filter || []) return { bool: booptimize({ ...(mustClauses.length && Q.must(...mustClauses)), @@ -419,55 +475,42 @@ namespace Q { } } - export function or (...queries: t.AnyBoolQuery[]): t.BoolQuery { + export function or (...queries: AnyQuery[]): BoolBlock { return { - query: { - bool: booptimize(Q.should(...queries)) - } + bool: booptimize(Q.should(...queries)) } } - export function not (q: t.AnyBoolQuery): t.BoolQuery { - if (!isBool(q) && !isBoolBlock(q) && !isClause(q)) { - return { - query: { - bool: Q.mustNot(q) - } - } - } - - const b = toClause(q) + export function not (q: T.QueryContainer): BoolBlock + export function not (q: T.BoolQuery): BoolBlock + export function not (q: any): BoolBlock { + const b = toBoolQuery(q) if (onlyMust(b)) { return { - query: { - bool: booptimize(Q.mustNot(...b.must)) - } + bool: booptimize(Q.mustNot(...b.must)) } } else if (onlyMustNot(b)) { return { - query: { - bool: booptimize(Q.must(...b.must_not)) - } + bool: booptimize(Q.must(...b.must_not)) } } else { return { - query: { - bool: booptimize(Q.mustNot(toBoolBlock(b))) - } + bool: booptimize(Q.mustNot(toBoolBlock(b))) } } } - export function minShouldMatch (int: number): t.BoolQueryOptions { + export function minShouldMatch (int: number): T.BoolQuery { return { minimum_should_match: int } } - export function name (queryName: string): t.BoolQueryOptions { + export function name (queryName: string): T.BoolQuery { return { _name: queryName } } - export function nested (path: string, query: any, opts: Record): t.QueryBlock { + type NestedContainer = { query: { nested: T.NestedQuery } } + export function nested (path: string, query: any, opts: Record): NestedContainer { return { query: { nested: { @@ -479,7 +522,8 @@ namespace Q { } } - export function constantScore (query: any, boost: number): t.QueryBlock { + type ConstantScoreContainer = { query: { constant_score: T.ConstantScoreQuery } } + export function constantScore (query: any, boost: number): ConstantScoreContainer { return { query: { constant_score: { @@ -490,7 +534,8 @@ namespace Q { } } - export function disMax (queries: t.AnyQuery[], opts?: Record): t.QueryBlock { + type DisMaxContainer = { query: { dis_max: T.DisMaxQuery } } + export function disMax (queries: T.QueryContainer[], opts?: Record): DisMaxContainer { return { query: { dis_max: { @@ -509,7 +554,7 @@ namespace Q { return { query: { boosting: boostOpts } } } - export function sort (key: string | any[], opts?: Record): t.Condition { + export function sort (key: string | any[], opts: Record | string): t.Condition { if (Array.isArray(key) === true) { return { sort: key } } @@ -525,7 +570,7 @@ namespace Q { } // Tries to flat a bool query based on the content -function booptimize (q: t.BoolQueryOptions): t.BoolQueryOptions { +function booptimize (q: T.BoolQuery): T.BoolQuery { const clauses: t.BoolQueryOptions = {} if (q.minimum_should_match !== undefined || @@ -622,7 +667,7 @@ function booptimize (q: t.BoolQueryOptions): t.BoolQueryOptions { function generateQueryObject (queryType: string, key: string, val: string | Symbol, opts?: Record): t.Condition function generateQueryObject (queryType: string, key: string, val: string[], opts?: Record): t.Condition[] -function generateQueryObject (queryType: string, key: string, val: any, opts?: Record): t.Condition | t.Condition[] { +function generateQueryObject (queryType: string, key: string, val: any, opts?: Record): any { if (Array.isArray(val)) { return val.map(v => generateQueryObject(queryType, key, v, opts)) } @@ -641,7 +686,7 @@ function generateQueryObject (queryType: string, key: string, val: any, opts?: R function generateValueObject (queryType: string, key: string, val: string | Symbol, opts?: Record): t.Condition function generateValueObject (queryType: string, key: string, val: string[], opts?: Record): t.Condition[] -function generateValueObject (queryType: string, key: string, val: any, opts?: Record): t.Condition | t.Condition[] { +function generateValueObject (queryType: string, key: string, val: any, opts?: Record): any { if (Array.isArray(val)) { return val.map(v => generateValueObject(queryType, key, v, opts)) } @@ -658,19 +703,15 @@ function generateValueObject (queryType: string, key: string, val: any, opts?: R } } -function isQuery (q: any): q is t.QueryBlock { +function isQuery (q: any): q is QueryBlock { return !!q.query } -function isBool (q: any): q is t.BoolQuery { - return q.query && q.query.bool -} - -function isBoolBlock (q: any): q is t.BoolBlock { +function isBoolBlock (q: any): q is BoolBlock { return !!q.bool } -function isClause (q: any): q is t.BoolQueryOptions { +function isBoolQuery (q: any): q is T.BoolQuery { if (q.must !== undefined) return true if (q.should !== undefined) return true if (q.must_not !== undefined) return true @@ -680,7 +721,7 @@ function isClause (q: any): q is t.BoolQueryOptions { return false } -function onlyShould (bool: t.BoolQueryOptions): bool is t.ShouldClause { +function onlyShould (bool: T.BoolQuery): bool is t.ShouldClause { if (bool.must !== undefined) return false if (bool.must_not !== undefined) return false if (bool.filter !== undefined) return false @@ -689,7 +730,7 @@ function onlyShould (bool: t.BoolQueryOptions): bool is t.ShouldClause { return true } -function onlyMust (bool: t.BoolQueryOptions): bool is t.MustClause { +function onlyMust (bool: T.BoolQuery): bool is t.MustClause { if (bool.should !== undefined) return false if (bool.must_not !== undefined) return false if (bool.filter !== undefined) return false @@ -698,7 +739,7 @@ function onlyMust (bool: t.BoolQueryOptions): bool is t.MustClause { return true } -function onlyMustNot (bool: t.BoolQueryOptions): bool is t.MustNotClause { +function onlyMustNot (bool: T.BoolQuery): bool is t.MustNotClause { if (bool.should !== undefined) return false if (bool.must !== undefined) return false if (bool.filter !== undefined) return false @@ -707,7 +748,7 @@ function onlyMustNot (bool: t.BoolQueryOptions): bool is t.MustNotClause { return true } -function onlyFilter (bool: t.BoolQueryOptions): bool is t.FilterClause { +function onlyFilter (bool: T.BoolQuery): bool is t.FilterClause { if (bool.should !== undefined) return false if (bool.must !== undefined) return false if (bool.must_not !== undefined) return false @@ -720,19 +761,15 @@ function onlyFilter (bool: t.BoolQueryOptions): bool is t.FilterClause { // - if is a bool query returns the bool block // - if is a clause, wraps the query in a bool block // - if is condition, wraps the query into a must clause and then in a bool block -function toBoolBlock (query: t.AnyBoolQuery): t.BoolBlock { - if (isBool(query)) { - return query.query +function toBoolBlock (query: T.QueryContainer | T.BoolQuery): BoolBlock { + if (isBoolQuery(query)) { + return { bool: query } } if (isBoolBlock(query)) { return query } - if (isClause(query)) { - return { bool: query } - } - return { bool: { must: [query] } } } @@ -740,16 +777,10 @@ function toBoolBlock (query: t.AnyBoolQuery): t.BoolBlock { // - if is a bool query returns the bool query options // - if is a clause, it returns it // - if is condition, wraps the query into a must clause and returns it -type toClauseDefault = 'must' | 'must_not' | 'should' | 'filter' -function toClause (query: t.AnyBoolQuery, def: toClauseDefault = 'must'): t.BoolQueryOptions { - if (isBool(query)) { - if (query.query.bool._name) { - return { [def]: [query.query] } - } - if (query.query.bool.minimum_should_match) { - return { [def]: [query.query] } - } - return query.query.bool +type toBoolQueryDefault = 'must' | 'must_not' | 'should' | 'filter' +function toBoolQuery (query: T.QueryContainer | T.BoolQuery, def: toBoolQueryDefault = 'must'): T.BoolQuery { + if (isBoolQuery(query)) { + return query } if (isBoolBlock(query)) { @@ -762,32 +793,24 @@ function toClause (query: t.AnyBoolQuery, def: toClauseDefault = 'must'): t.Bool return query.bool } - if (isClause(query)) { - return query - } - return { [def]: [query] } } // the aim of this mergeable functions // is to reduce the depth of the query objects -function mergeableMust (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { +function mergeableMust (q: T.QueryContainer | T.BoolQuery): T.QueryContainer +function mergeableMust (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] +function mergeableMust (q: any): any { if (Array.isArray(q)) { return q.map(mergeableMust) } - if (isBool(q)) { - if (onlyMust(q.query.bool)) { - return q.query.bool.must - } else { - return q.query - } - } else if (isBoolBlock(q)) { + if (isBoolBlock(q)) { if (onlyMust(q.bool)) { return q.bool.must } else { return q } - } else if (isClause(q)) { + } else if (isBoolQuery(q)) { if (onlyMust(q)) { return q.must } else { @@ -798,23 +821,19 @@ function mergeableMust (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { } } -function mergeableShould (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { +function mergeableShould (q: T.QueryContainer | T.BoolQuery): T.QueryContainer +function mergeableShould (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] +function mergeableShould (q: any): any { if (Array.isArray(q)) { return q.map(mergeableShould) } - if (isBool(q)) { - if (onlyShould(q.query.bool)) { - return q.query.bool.should - } else { - return q.query - } - } else if (isBoolBlock(q)) { + if (isBoolBlock(q)) { if (onlyShould(q.bool)) { return q.bool.should } else { return q } - } else if (isClause(q)) { + } else if (isBoolQuery(q)) { if (onlyShould(q)) { return q.should } else { @@ -825,23 +844,20 @@ function mergeableShould (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { } } -function mergeableMustNot (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { +function mergeableMustNot (q: T.QueryContainer | T.BoolQuery): T.QueryContainer +function mergeableMustNot (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] +function mergeableMustNot (q: any): any { if (Array.isArray(q)) { return q.map(mergeableMustNot) } - if (isBool(q)) { - if (onlyMustNot(q.query.bool)) { - return q.query.bool.must_not - } else { - return q.query - } - } else if (isBoolBlock(q)) { + + if (isBoolBlock(q)) { if (onlyMustNot(q.bool)) { return q.bool.must_not } else { return q } - } else if (isClause(q)) { + } else if (isBoolQuery(q)) { if (onlyMustNot(q)) { return q.must_not } else { @@ -852,23 +868,19 @@ function mergeableMustNot (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { } } -function mergeableFilter (q: t.AnyQuery): t.AnyQuery | t.AnyQuery[] { +function mergeableFilter (q: T.QueryContainer | T.BoolQuery): T.QueryContainer +function mergeableFilter (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] +function mergeableFilter (q: any): any { if (Array.isArray(q)) { return q.map(mergeableFilter) } - if (isBool(q)) { - if (onlyFilter(q.query.bool)) { - return q.query.bool.filter - } else { - return q.query - } - } else if (isBoolBlock(q)) { + if (isBoolBlock(q)) { if (onlyFilter(q.bool)) { return q.bool.filter } else { return q } - } else if (isClause(q)) { + } else if (isBoolQuery(q)) { if (onlyFilter(q)) { return q.filter } else {