@elastic/elasticsearch/lib/api/types.d.ts

The official Elasticsearch client for Node.js

/**
 * We are still working on this type, it will arrive soon.
 * If it's critical for you, please open an issue.
 * https://github.com/elastic/elasticsearch-js
 */
export declare type TODO = Record<string, any>;
export interface BulkCreateOperation extends BulkWriteOperation {
}
export interface BulkDeleteOperation extends BulkOperationBase {
}
export interface BulkIndexOperation extends BulkWriteOperation {
}
export interface BulkOperationBase {
    _id?: Id;
    _index?: IndexName;
    routing?: Routing;
    if_primary_term?: long;
    if_seq_no?: SequenceNumber;
    version?: VersionNumber;
    version_type?: VersionType;
}
export interface BulkOperationContainer {
    index?: BulkIndexOperation;
    create?: BulkCreateOperation;
    update?: BulkUpdateOperation;
    delete?: BulkDeleteOperation;
}
export declare type BulkOperationType = 'index' | 'create' | 'update' | 'delete';
export interface BulkRequest<TDocument = unknown, TPartialDocument = unknown> extends RequestBase {
    index?: IndexName;
    pipeline?: string;
    refresh?: Refresh;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    timeout?: Time;
    wait_for_active_shards?: WaitForActiveShards;
    require_alias?: boolean;
    operations?: (BulkOperationContainer | BulkUpdateAction<TDocument, TPartialDocument> | TDocument)[];
}
export interface BulkResponse {
    errors: boolean;
    items: Partial<Record<BulkOperationType, BulkResponseItem>>[];
    took: long;
    ingest_took?: long;
}
export interface BulkResponseItem {
    _id?: string | null;
    _index: string;
    status: integer;
    error?: ErrorCause;
    _primary_term?: long;
    result?: string;
    _seq_no?: SequenceNumber;
    _shards?: ShardStatistics;
    _version?: VersionNumber;
    forced_refresh?: boolean;
    get?: InlineGet<Record<string, any>>;
}
export interface BulkUpdateAction<TDocument = unknown, TPartialDocument = unknown> {
    detect_noop?: boolean;
    doc?: TPartialDocument;
    doc_as_upsert?: boolean;
    script?: Script;
    scripted_upsert?: boolean;
    _source?: SearchSourceConfig;
    upsert?: TDocument;
}
export interface BulkUpdateOperation extends BulkOperationBase {
    require_alias?: boolean;
    retry_on_conflict?: integer;
}
export interface BulkWriteOperation extends BulkOperationBase {
    dynamic_templates?: Record<string, string>;
    pipeline?: string;
    require_alias?: boolean;
}
export interface ClearScrollRequest extends RequestBase {
    scroll_id?: Ids;
}
export interface ClearScrollResponse {
    succeeded: boolean;
    num_freed: integer;
}
export interface ClosePointInTimeRequest extends RequestBase {
    id: Id;
}
export interface ClosePointInTimeResponse {
    succeeded: boolean;
    num_freed: integer;
}
export interface CountRequest extends RequestBase {
    index?: Indices;
    allow_no_indices?: boolean;
    analyzer?: string;
    analyze_wildcard?: boolean;
    default_operator?: QueryDslOperator;
    df?: string;
    expand_wildcards?: ExpandWildcards;
    ignore_throttled?: boolean;
    ignore_unavailable?: boolean;
    lenient?: boolean;
    min_score?: double;
    preference?: string;
    routing?: Routing;
    terminate_after?: long;
    q?: string;
    query?: QueryDslQueryContainer;
}
export interface CountResponse {
    count: long;
    _shards: ShardStatistics;
}
export interface CreateRequest<TDocument = unknown> extends RequestBase {
    id: Id;
    index: IndexName;
    pipeline?: string;
    refresh?: Refresh;
    routing?: Routing;
    timeout?: Time;
    version?: VersionNumber;
    version_type?: VersionType;
    wait_for_active_shards?: WaitForActiveShards;
    document?: TDocument;
}
export declare type CreateResponse = WriteResponseBase;
export interface DeleteRequest extends RequestBase {
    id: Id;
    index: IndexName;
    if_primary_term?: long;
    if_seq_no?: SequenceNumber;
    refresh?: Refresh;
    routing?: Routing;
    timeout?: Time;
    version?: VersionNumber;
    version_type?: VersionType;
    wait_for_active_shards?: WaitForActiveShards;
}
export declare type DeleteResponse = WriteResponseBase;
export interface DeleteByQueryRequest extends RequestBase {
    index: Indices;
    allow_no_indices?: boolean;
    analyzer?: string;
    analyze_wildcard?: boolean;
    conflicts?: Conflicts;
    default_operator?: QueryDslOperator;
    df?: string;
    expand_wildcards?: ExpandWildcards;
    from?: long;
    ignore_unavailable?: boolean;
    lenient?: boolean;
    max_docs?: long;
    preference?: string;
    refresh?: boolean;
    request_cache?: boolean;
    requests_per_second?: long;
    routing?: Routing;
    q?: string;
    scroll?: Time;
    scroll_size?: long;
    search_timeout?: Time;
    search_type?: SearchType;
    slices?: long;
    sort?: string[];
    stats?: string[];
    terminate_after?: long;
    timeout?: Time;
    version?: boolean;
    wait_for_active_shards?: WaitForActiveShards;
    wait_for_completion?: boolean;
    query?: QueryDslQueryContainer;
    slice?: SlicedScroll;
}
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;
}
export interface DeleteByQueryRethrottleRequest extends RequestBase {
    task_id: Id;
    requests_per_second?: long;
}
export declare type DeleteByQueryRethrottleResponse = TasksTaskListResponseBase;
export interface DeleteScriptRequest extends RequestBase {
    id: Id;
    master_timeout?: Time;
    timeout?: Time;
}
export declare type DeleteScriptResponse = AcknowledgedResponseBase;
export interface ExistsRequest extends RequestBase {
    id: Id;
    index: IndexName;
    preference?: string;
    realtime?: boolean;
    refresh?: boolean;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    stored_fields?: Fields;
    version?: VersionNumber;
    version_type?: VersionType;
}
export declare type ExistsResponse = boolean;
export interface ExistsSourceRequest extends RequestBase {
    id: Id;
    index: IndexName;
    preference?: string;
    realtime?: boolean;
    refresh?: boolean;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    version?: VersionNumber;
    version_type?: VersionType;
}
export declare type ExistsSourceResponse = boolean;
export interface ExplainExplanation {
    description: string;
    details: ExplainExplanationDetail[];
    value: float;
}
export interface ExplainExplanationDetail {
    description: string;
    details?: ExplainExplanationDetail[];
    value: float;
}
export interface ExplainRequest extends RequestBase {
    id: Id;
    index: IndexName;
    analyzer?: string;
    analyze_wildcard?: boolean;
    default_operator?: QueryDslOperator;
    df?: string;
    lenient?: boolean;
    preference?: string;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    stored_fields?: Fields;
    q?: string;
    query?: QueryDslQueryContainer;
}
export interface ExplainResponse<TDocument = unknown> {
    _index: IndexName;
    _id: Id;
    matched: boolean;
    explanation?: ExplainExplanationDetail;
    get?: InlineGet<TDocument>;
}
export interface FieldCapsFieldCapability {
    aggregatable: boolean;
    indices?: Indices;
    meta?: Metadata;
    non_aggregatable_indices?: Indices;
    non_searchable_indices?: Indices;
    searchable: boolean;
    type: string;
    metadata_field?: boolean;
    time_series_dimension?: boolean;
    time_series_metric?: MappingTimeSeriesMetricType;
    non_dimension_indices?: IndexName[];
    metric_conflicts_indices?: IndexName[];
}
export interface FieldCapsRequest extends RequestBase {
    index?: Indices;
    allow_no_indices?: boolean;
    expand_wildcards?: ExpandWildcards;
    fields: Fields;
    ignore_unavailable?: boolean;
    include_unmapped?: boolean;
    filters?: string;
    types?: string[];
    index_filter?: QueryDslQueryContainer;
    runtime_mappings?: MappingRuntimeFields;
}
export interface FieldCapsResponse {
    indices: Indices;
    fields: Record<Field, Record<string, FieldCapsFieldCapability>>;
}
export interface GetGetResult<TDocument = unknown> {
    _index: IndexName;
    fields?: Record<string, any>;
    found: boolean;
    _id: Id;
    _primary_term?: long;
    _routing?: string;
    _seq_no?: SequenceNumber;
    _source?: TDocument;
    _version?: VersionNumber;
}
export interface GetRequest extends RequestBase {
    id: Id;
    index: IndexName;
    preference?: string;
    realtime?: boolean;
    refresh?: boolean;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    stored_fields?: Fields;
    version?: VersionNumber;
    version_type?: VersionType;
}
export declare type GetResponse<TDocument = unknown> = GetGetResult<TDocument>;
export interface GetScriptRequest extends RequestBase {
    id: Id;
    master_timeout?: Time;
}
export interface GetScriptResponse {
    _id: Id;
    found: boolean;
    script?: StoredScript;
}
export interface GetScriptContextContext {
    methods: GetScriptContextContextMethod[];
    name: Name;
}
export interface GetScriptContextContextMethod {
    name: Name;
    return_type: string;
    params: GetScriptContextContextMethodParam[];
}
export interface GetScriptContextContextMethodParam {
    name: Name;
    type: string;
}
export interface GetScriptContextRequest extends RequestBase {
}
export interface GetScriptContextResponse {
    contexts: GetScriptContextContext[];
}
export interface GetScriptLanguagesLanguageContext {
    contexts: string[];
    language: ScriptLanguage;
}
export interface GetScriptLanguagesRequest extends RequestBase {
}
export interface GetScriptLanguagesResponse {
    language_contexts: GetScriptLanguagesLanguageContext[];
    types_allowed: string[];
}
export interface GetSourceRequest {
    id: Id;
    index: IndexName;
    preference?: string;
    realtime?: boolean;
    refresh?: boolean;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    stored_fields?: Fields;
    version?: VersionNumber;
    version_type?: VersionType;
}
export declare type GetSourceResponse<TDocument = unknown> = TDocument;
export interface IndexRequest<TDocument = unknown> extends RequestBase {
    id?: Id;
    index: IndexName;
    if_primary_term?: long;
    if_seq_no?: SequenceNumber;
    op_type?: OpType;
    pipeline?: string;
    refresh?: Refresh;
    routing?: Routing;
    timeout?: Time;
    version?: VersionNumber;
    version_type?: VersionType;
    wait_for_active_shards?: WaitForActiveShards;
    require_alias?: boolean;
    document?: TDocument;
}
export declare type IndexResponse = WriteResponseBase;
export interface InfoRequest extends RequestBase {
}
export interface InfoResponse {
    cluster_name: Name;
    cluster_uuid: Uuid;
    name: Name;
    tagline: string;
    version: ElasticsearchVersionInfo;
}
export interface KnnSearchRequest extends RequestBase {
    index: Indices;
    routing?: Routing;
    _source?: SearchSourceConfig;
    docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
    stored_fields?: Fields;
    fields?: Fields;
    filter?: QueryDslQueryContainer | QueryDslQueryContainer[];
    knn: KnnSearchQuery;
}
export interface KnnSearchResponse<TDocument = unknown> {
    took: long;
    timed_out: boolean;
    _shards: ShardStatistics;
    hits: SearchHitsMetadata<TDocument>;
    fields?: Record<string, any>;
    max_score?: double;
}
export interface KnnSearchQuery {
    field: Field;
    query_vector: KnnSearchQueryVector;
    k: long;
    num_candidates: long;
}
export declare type KnnSearchQueryVector = double[];
export interface MgetMultiGetError {
    error: ErrorCause;
    _id: Id;
    _index: IndexName;
}
export interface MgetOperation {
    _id: Id;
    _index?: IndexName;
    routing?: Routing;
    _source?: SearchSourceConfig;
    stored_fields?: Fields;
    version?: VersionNumber;
    version_type?: VersionType;
}
export interface MgetRequest extends RequestBase {
    index?: IndexName;
    preference?: string;
    realtime?: boolean;
    refresh?: boolean;
    routing?: Routing;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    stored_fields?: Fields;
    docs?: MgetOperation[];
    ids?: Ids;
}
export interface MgetResponse<TDocument = unknown> {
    docs: MgetResponseItem<TDocument>[];
}
export declare type MgetResponseItem<TDocument = unknown> = GetGetResult<TDocument> | MgetMultiGetError;
export interface MsearchMultiSearchItem<TDocument = unknown> extends SearchResponseBody<TDocument> {
    status?: integer;
}
export interface MsearchMultiSearchResult<TDocument = unknown> {
    took: long;
    responses: MsearchResponseItem<TDocument>[];
}
export interface MsearchMultisearchBody {
    aggregations?: Record<string, AggregationsAggregationContainer>;
    aggs?: Record<string, AggregationsAggregationContainer>;
    query?: QueryDslQueryContainer;
    explain?: boolean;
    stored_fields?: Fields;
    docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
    from?: integer;
    size?: integer;
    sort?: Sort;
    _source?: SearchSourceConfig;
    terminate_after?: long;
    stats?: string[];
    timeout?: string;
    track_scores?: boolean;
    track_total_hits?: SearchTrackHits;
    version?: boolean;
    seq_no_primary_term?: boolean;
    pit?: SearchPointInTimeReference;
    suggest?: SearchSuggester;
}
export interface MsearchMultisearchHeader {
    allow_no_indices?: boolean;
    expand_wildcards?: ExpandWildcards;
    ignore_unavailable?: boolean;
    index?: Indices;
    preference?: string;
    request_cache?: boolean;
    routing?: string;
    search_type?: SearchType;
    ccs_minimize_roundtrips?: boolean;
    allow_partial_search_results?: boolean;
    ignore_throttled?: boolean;
}
export interface MsearchRequest extends RequestBase {
    index?: Indices;
    allow_no_indices?: boolean;
    ccs_minimize_roundtrips?: boolean;
    expand_wildcards?: ExpandWildcards;
    ignore_throttled?: boolean;
    ignore_unavailable?: boolean;
    max_concurrent_searches?: long;
    max_concurrent_shard_requests?: long;
    pre_filter_shard_size?: long;
    search_type?: SearchType;
    rest_total_hits_as_int?: boolean;
    typed_keys?: boolean;
    searches?: MsearchRequestItem[];
}
export declare type MsearchRequestItem = MsearchMultisearchHeader | MsearchMultisearchBody;
export declare type MsearchResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = MsearchMultiSearchResult<TDocument>;
export declare type MsearchResponseItem<TDocument = unknown> = MsearchMultiSearchItem<TDocument> | ErrorResponseBase;
export interface MsearchTemplateRequest extends RequestBase {
    index?: Indices;
    ccs_minimize_roundtrips?: boolean;
    max_concurrent_searches?: long;
    search_type?: SearchType;
    rest_total_hits_as_int?: boolean;
    typed_keys?: boolean;
    search_templates?: MsearchTemplateRequestItem[];
}
export declare type MsearchTemplateRequestItem = MsearchMultisearchHeader | MsearchTemplateTemplateConfig;
export declare type MsearchTemplateResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = MsearchMultiSearchResult<TDocument>;
export interface MsearchTemplateTemplateConfig {
    explain?: boolean;
    id?: Id;
    params?: Record<string, any>;
    profile?: boolean;
    source?: string;
}
export interface MtermvectorsOperation {
    _id: Id;
    _index?: IndexName;
    doc?: any;
    fields?: Fields;
    field_statistics?: boolean;
    filter?: TermvectorsFilter;
    offsets?: boolean;
    payloads?: boolean;
    positions?: boolean;
    routing?: Routing;
    term_statistics?: boolean;
    version?: VersionNumber;
    version_type?: VersionType;
}
export interface MtermvectorsRequest extends RequestBase {
    index?: IndexName;
    ids?: Id[];
    fields?: Fields;
    field_statistics?: boolean;
    offsets?: boolean;
    payloads?: boolean;
    positions?: boolean;
    preference?: string;
    realtime?: boolean;
    routing?: Routing;
    term_statistics?: boolean;
    version?: VersionNumber;
    version_type?: VersionType;
    docs?: MtermvectorsOperation[];
}
export interface MtermvectorsResponse {
    docs: MtermvectorsTermVectorsResult[];
}
export interface MtermvectorsTermVectorsResult {
    _id: Id;
    _index: IndexName;
    _version?: VersionNumber;
    took?: long;
    found?: boolean;
    term_vectors?: Record<Field, TermvectorsTermVector>;
    error?: ErrorCause;
}
export interface OpenPointInTimeRequest extends RequestBase {
    index: Indices;
    keep_alive: Time;
    ignore_unavailable?: boolean;
}
export interface OpenPointInTimeResponse {
    id: Id;
}
export interface PingRequest extends RequestBase {
}
export declare type PingResponse = boolean;
export interface PutScriptRequest extends RequestBase {
    id: Id;
    context?: Name;
    master_timeout?: Time;
    timeout?: Time;
    script: StoredScript;
}
export declare type PutScriptResponse = AcknowledgedResponseBase;
export interface RankEvalDocumentRating {
    _id: Id;
    _index: IndexName;
    rating: integer;
}
export interface RankEvalRankEvalHit {
    _id: Id;
    _index: IndexName;
    _score: double;
}
export interface RankEvalRankEvalHitItem {
    hit: RankEvalRankEvalHit;
    rating?: double | null;
}
export interface RankEvalRankEvalMetric {
    precision?: RankEvalRankEvalMetricPrecision;
    recall?: RankEvalRankEvalMetricRecall;
    mean_reciprocal_rank?: RankEvalRankEvalMetricMeanReciprocalRank;
    dcg?: RankEvalRankEvalMetricDiscountedCumulativeGain;
    expected_reciprocal_rank?: RankEvalRankEvalMetricExpectedReciprocalRank;
}
export interface RankEvalRankEvalMetricBase {
    k?: integer;
}
export interface RankEvalRankEvalMetricDetail {
    metric_score: double;
    unrated_docs: RankEvalUnratedDocument[];
    hits: RankEvalRankEvalHitItem[];
    metric_details: Record<string, Record<string, any>>;
}
export interface RankEvalRankEvalMetricDiscountedCumulativeGain extends RankEvalRankEvalMetricBase {
    normalize?: boolean;
}
export interface RankEvalRankEvalMetricExpectedReciprocalRank extends RankEvalRankEvalMetricBase {
    maximum_relevance: integer;
}
export interface RankEvalRankEvalMetricMeanReciprocalRank extends RankEvalRankEvalMetricRatingTreshold {
}
export interface RankEvalRankEvalMetricPrecision extends RankEvalRankEvalMetricRatingTreshold {
    ignore_unlabeled?: boolean;
}
export interface RankEvalRankEvalMetricRatingTreshold extends RankEvalRankEvalMetricBase {
    relevant_rating_threshold?: integer;
}
export interface RankEvalRankEvalMetricRecall extends RankEvalRankEvalMetricRatingTreshold {
}
export interface RankEvalRankEvalQuery {
    query: QueryDslQueryContainer;
    size?: integer;
}
export interface RankEvalRankEvalRequestItem {
    id: Id;
    request?: RankEvalRankEvalQuery;
    ratings: RankEvalDocumentRating[];
    template_id?: Id;
    params?: Record<string, any>;
}
export interface RankEvalRequest extends RequestBase {
    index: Indices;
    allow_no_indices?: boolean;
    expand_wildcards?: ExpandWildcards;
    ignore_unavailable?: boolean;
    search_type?: string;
    requests: RankEvalRankEvalRequestItem[];
    metric?: RankEvalRankEvalMetric;
}
export interface RankEvalResponse {
    metric_score: double;
    details: Record<Id, RankEvalRankEvalMetricDetail>;
    failures: Record<string, any>;
}
export interface RankEvalUnratedDocument {
    _id: Id;
    _index: IndexName;
}
export interface ReindexDestination {
    index: IndexName;
    op_type?: OpType;
    pipeline?: string;
    routing?: Routing;
    version_type?: VersionType;
}
export interface ReindexRemoteSource {
    connect_timeout: Time;
    host: Host;
    username: Username;
    password: Password;
    socket_timeout: Time;
}
export interface ReindexRequest extends RequestBase {
    refresh?: boolean;
    requests_per_second?: long;
    scroll?: Time;
    slices?: long;
    timeout?: Time;
    wait_for_active_shards?: WaitForActiveShards;
    wait_for_completion?: boolean;
    require_alias?: boolean;
    conflicts?: Conflicts;
    dest: ReindexDestination;
    max_docs?: long;
    script?: Script;
    size?: long;
    source: ReindexSource;
}
export interface ReindexResponse {
    batches?: long;
    created?: long;
    deleted?: long;
    failures?: BulkIndexByScrollFailure[];
    noops?: long;
    retries?: Retries;
    requests_per_second?: long;
    slice_id?: integer;
    task?: TaskId;
    throttled_millis?: EpochMillis;
    throttled_until_millis?: EpochMillis;
    timed_out?: boolean;
    took?: Time;
    total?: long;
    updated?: long;
    version_conflicts?: long;
}
export interface ReindexSource {
    index: Indices;
    query?: QueryDslQueryContainer;
    remote?: ReindexRemoteSource;
    size?: integer;
    slice?: SlicedScroll;
    sort?: Sort;
    _source?: Fields;
    runtime_mappings?: MappingRuntimeFields;
}
export interface ReindexRethrottleReindexNode extends SpecUtilsBaseNode {
    tasks: Record<TaskId, ReindexRethrottleReindexTask>;
}
export interface ReindexRethrottleReindexStatus {
    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 ReindexRethrottleReindexTask {
    action: string;
    cancellable: boolean;
    description: string;
    id: long;
    node: Name;
    running_time_in_nanos: long;
    start_time_in_millis: long;
    status: ReindexRethrottleReindexStatus;
    type: string;
    headers: HttpHeaders;
}
export interface ReindexRethrottleRequest extends RequestBase {
    task_id: Id;
    requests_per_second?: long;
}
export interface ReindexRethrottleResponse {
    nodes: Record<string, ReindexRethrottleReindexNode>;
}
export interface RenderSearchTemplateRequest extends RequestBase {
    id?: Id;
    file?: string;
    params?: Record<string, any>;
    source?: string;
}
export interface RenderSearchTemplateResponse {
    template_output: Record<string, any>;
}
export interface ScriptsPainlessExecutePainlessContextSetup {
    document: any;
    index: IndexName;
    query: QueryDslQueryContainer;
}
export interface ScriptsPainlessExecuteRequest extends RequestBase {
    context?: string;
    context_setup?: ScriptsPainlessExecutePainlessContextSetup;
    script?: InlineScript | string;
}
export interface ScriptsPainlessExecuteResponse<TResult = unknown> {
    result: TResult;
}
export interface ScrollRequest extends RequestBase {
    scroll_id?: ScrollId;
    scroll?: Time;
    rest_total_hits_as_int?: boolean;
}
export declare type ScrollResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = SearchResponseBody<TDocument, TAggregations>;
export interface SearchRequest extends RequestBase {
    index?: Indices;
    allow_no_indices?: boolean;
    allow_partial_search_results?: boolean;
    analyzer?: string;
    analyze_wildcard?: boolean;
    batched_reduce_size?: long;
    ccs_minimize_roundtrips?: boolean;
    default_operator?: QueryDslOperator;
    df?: string;
    docvalue_fields?: Fields;
    expand_wildcards?: ExpandWildcards;
    explain?: boolean;
    ignore_throttled?: boolean;
    ignore_unavailable?: boolean;
    lenient?: boolean;
    max_concurrent_shard_requests?: long;
    min_compatible_shard_node?: VersionString;
    preference?: string;
    pre_filter_shard_size?: long;
    request_cache?: boolean;
    routing?: Routing;
    scroll?: Time;
    search_type?: SearchType;
    stats?: string[];
    stored_fields?: Fields;
    suggest_field?: Field;
    suggest_mode?: SuggestMode;
    suggest_size?: long;
    suggest_text?: string;
    terminate_after?: long;
    timeout?: Time;
    track_total_hits?: SearchTrackHits;
    track_scores?: boolean;
    typed_keys?: boolean;
    rest_total_hits_as_int?: boolean;
    version?: boolean;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    seq_no_primary_term?: boolean;
    q?: string;
    size?: integer;
    from?: integer;
    sort?: string | string[];
    aggregations?: Record<string, AggregationsAggregationContainer>;
    aggs?: Record<string, AggregationsAggregationContainer>;
    collapse?: SearchFieldCollapse;
    highlight?: SearchHighlight;
    indices_boost?: Record<IndexName, double>[];
    min_score?: double;
    post_filter?: QueryDslQueryContainer;
    profile?: boolean;
    query?: QueryDslQueryContainer;
    rescore?: SearchRescore | SearchRescore[];
    script_fields?: Record<string, ScriptField>;
    search_after?: SortResults;
    slice?: SlicedScroll;
    fields?: (QueryDslFieldAndFormat | Field)[];
    suggest?: SearchSuggester;
    pit?: SearchPointInTimeReference;
    runtime_mappings?: MappingRuntimeFields;
}
export declare type SearchResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = SearchResponseBody<TDocument, TAggregations>;
export interface SearchResponseBody<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> {
    took: long;
    timed_out: boolean;
    _shards: ShardStatistics;
    hits: SearchHitsMetadata<TDocument>;
    aggregations?: TAggregations;
    _clusters?: ClusterStatistics;
    fields?: Record<string, any>;
    max_score?: double;
    num_reduce_phases?: long;
    profile?: SearchProfile;
    pit_id?: Id;
    _scroll_id?: ScrollId;
    suggest?: Record<SuggestionName, SearchSuggest<TDocument>[]>;
    terminated_early?: boolean;
}
export interface SearchAggregationBreakdown {
    build_aggregation: long;
    build_aggregation_count: long;
    build_leaf_collector: long;
    build_leaf_collector_count: long;
    collect: long;
    collect_count: long;
    initialize: long;
    initialize_count: long;
    post_collection?: long;
    post_collection_count?: long;
    reduce: long;
    reduce_count: long;
}
export interface SearchAggregationProfile {
    breakdown: SearchAggregationBreakdown;
    description: string;
    time_in_nanos: long;
    type: string;
    debug?: SearchAggregationProfileDebug;
    children?: SearchAggregationProfile[];
}
export interface SearchAggregationProfileDebug {
    segments_with_multi_valued_ords?: integer;
    collection_strategy?: string;
    segments_with_single_valued_ords?: integer;
    total_buckets?: integer;
    built_buckets?: integer;
    result_strategy?: string;
    has_filter?: boolean;
    delegate?: string;
    delegate_debug?: SearchAggregationProfileDebug;
    chars_fetched?: integer;
    extract_count?: integer;
    extract_ns?: integer;
    values_fetched?: integer;
    collect_analyzed_ns?: integer;
    collect_analyzed_count?: integer;
    surviving_buckets?: integer;
    ordinals_collectors_used?: integer;
    ordinals_collectors_overhead_too_high?: integer;
    string_hashing_collectors_used?: integer;
    numeric_collectors_used?: integer;
    empty_collectors_used?: integer;
    deferred_aggregators?: string[];
    segments_with_doc_count_field?: integer;
    segments_with_deleted_docs?: integer;
    filters?: SearchAggregationProfileDelegateDebugFilter[];
    segments_counted?: integer;
    segments_collected?: integer;
}
export interface SearchAggregationProfileDelegateDebugFilter {
    results_from_metadata?: integer;
    query?: string;
    specialized_for?: string;
}
export declare type SearchBoundaryScanner = 'chars' | 'sentence' | 'word';
export interface SearchCollector {
    name: string;
    reason: string;
    time_in_nanos: long;
    children?: SearchCollector[];
}
export interface SearchCompletionContext {
    boost?: double;
    context: SearchContext;
    neighbours?: GeoHashPrecision[];
    precision?: GeoHashPrecision;
    prefix?: boolean;
}
export interface SearchCompletionSuggest<TDocument = unknown> extends SearchSuggestBase {
    options: SearchCompletionSuggestOption<TDocument>[];
}
export interface SearchCompletionSuggestOption<TDocument = unknown> {
    collate_match?: boolean;
    contexts?: Record<string, SearchContext[]>;
    fields?: Record<string, any>;
    _id?: string;
    _index?: IndexName;
    _routing?: Routing;
    _score?: double;
    _source?: TDocument;
    text: string;
    score?: double;
}
export interface SearchCompletionSuggester extends SearchSuggesterBase {
    contexts?: Record<Field, SearchCompletionContext | SearchContext | (SearchCompletionContext | SearchContext)[]>;
    fuzzy?: SearchSuggestFuzziness;
    prefix?: string;
    regex?: string;
    skip_duplicates?: boolean;
}
export declare type SearchContext = string | GeoLocation;
export interface SearchDirectGenerator {
    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 SearchFetchProfile {
    type: string;
    description: string;
    time_in_nanos: long;
    breakdown: SearchFetchProfileBreakdown;
    debug?: SearchFetchProfileDebug;
    children?: SearchFetchProfile[];
}
export interface SearchFetchProfileBreakdown {
    load_stored_fields?: integer;
    load_stored_fields_count?: integer;
    next_reader?: integer;
    next_reader_count?: integer;
    process_count?: integer;
    process?: integer;
}
export interface SearchFetchProfileDebug {
    stored_fields?: string[];
    fast_path?: integer;
}
export interface SearchFieldCollapse {
    field: Field;
    inner_hits?: SearchInnerHits | SearchInnerHits[];
    max_concurrent_group_searches?: integer;
    collapse?: SearchFieldCollapse;
}
export interface SearchFieldSuggester {
    completion?: SearchCompletionSuggester;
    phrase?: SearchPhraseSuggester;
    term?: SearchTermSuggester;
    prefix?: string;
    regex?: string;
    text?: string;
}
export interface SearchHighlight {
    fields: Record<Field, SearchHighlightField>;
    type?: SearchHighlighterType;
    boundary_chars?: string;
    boundary_max_scan?: integer;
    boundary_scanner?: SearchBoundaryScanner;
    boundary_scanner_locale?: string;
    encoder?: SearchHighlighterEncoder;
    fragmenter?: SearchHighlighterFragmenter;
    fragment_offset?: integer;
    fragment_size?: integer;
    max_fragment_length?: integer;
    no_match_size?: integer;
    number_of_fragments?: integer;
    order?: SearchHighlighterOrder;
    post_tags?: string[];
    pre_tags?: string[];
    require_field_match?: boolean;
    tags_schema?: SearchHighlighterTagsSchema;
    highlight_query?: QueryDslQueryContainer;
    max_analyzed_offset?: string | integer;
}
export interface SearchHighlightField {
    boundary_chars?: string;
    boundary_max_scan?: integer;
    boundary_scanner?: SearchBoundaryScanner;
    boundary_scanner_locale?: string;
    field?: Field;
    force_source?: boolean;
    fragmenter?: SearchHighlighterFragmenter;
    fragment_offset?: integer;
    fragment_size?: integer;
    highlight_query?: QueryDslQueryContainer;
    matched_fields?: Fields;
    max_fragment_length?: integer;
    no_match_size?: integer;
    number_of_fragments?: integer;
    order?: SearchHighlighterOrder;
    phrase_limit?: integer;
    post_tags?: string[];
    pre_tags?: string[];
    require_field_match?: boolean;
    tags_schema?: SearchHighlighterTagsSchema;
    type?: SearchHighlighterType;
}
export declare type SearchHighlighterEncoder = 'default' | 'html';
export declare type SearchHighlighterFragmenter = 'simple' | 'span';
export declare type SearchHighlighterOrder = 'score';
export declare type SearchHighlighterTagsSchema = 'styled';
export declare type SearchHighlighterType = 'plain' | 'fvh' | 'unified' | string;
export interface SearchHit<TDocument = unknown> {
    _index: IndexName;
    _id: Id;
    _score?: double | null;
    _explanation?: ExplainExplanation;
    fields?: Record<string, any>;
    highlight?: Record<string, string[]>;
    inner_hits?: Record<string, SearchInnerHitsResult>;
    matched_queries?: string[];
    _nested?: SearchNestedIdentity;
    _ignored?: string[];
    ignored_field_values?: Record<string, string[]>;
    _shard?: string;
    _node?: string;
    _routing?: string;
    _source?: TDocument;
    _seq_no?: SequenceNumber;
    _primary_term?: long;
    _version?: VersionNumber;
    sort?: SortResults;
}
export interface SearchHitsMetadata<T = unknown> {
    total?: SearchTotalHits | long;
    hits: SearchHit<T>[];
    max_score?: double | null;
}
export interface SearchInnerHits {
    name?: Name;
    size?: integer;
    from?: integer;
    collapse?: SearchFieldCollapse;
    docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
    explain?: boolean;
    highlight?: SearchHighlight;
    ignore_unmapped?: boolean;
    script_fields?: Record<Field, ScriptField>;
    seq_no_primary_term?: boolean;
    fields?: Fields;
    sort?: Sort;
    _source?: SearchSourceConfig;
    stored_field?: Fields;
    track_scores?: boolean;
    version?: boolean;
}
export interface SearchInnerHitsResult {
    hits: SearchHitsMetadata<any>;
}
export interface SearchLaplaceSmoothingModel {
    alpha: double;
}
export interface SearchLinearInterpolationSmoothingModel {
    bigram_lambda: double;
    trigram_lambda: double;
    unigram_lambda: double;
}
export interface SearchNestedIdentity {
    field: Field;
    offset: integer;
    _nested?: SearchNestedIdentity;
}
export interface SearchPhraseSuggest extends SearchSuggestBase {
    options: SearchPhraseSuggestOption;
}
export interface SearchPhraseSuggestCollate {
    params?: Record<string, any>;
    prune?: boolean;
    query: SearchPhraseSuggestCollateQuery;
}
export interface SearchPhraseSuggestCollateQuery {
    id?: Id;
    source?: string;
}
export interface SearchPhraseSuggestHighlight {
    post_tag: string;
    pre_tag: string;
}
export interface SearchPhraseSuggestOption {
    text: string;
    highlighted: string;
    score: double;
}
export interface SearchPhraseSuggester extends SearchSuggesterBase {
    collate?: SearchPhraseSuggestCollate;
    confidence?: double;
    direct_generator?: SearchDirectGenerator[];
    force_unigrams?: boolean;
    gram_size?: integer;
    highlight?: SearchPhraseSuggestHighlight;
    max_errors?: double;
    real_word_error_likelihood?: double;
    separator?: string;
    shard_size?: integer;
    smoothing?: SearchSmoothingModelContainer;
    text?: string;
    token_limit?: integer;
}
export interface SearchPointInTimeReference {
    id: Id;
    keep_alive?: Time;
}
export interface SearchProfile {
    shards: SearchShardProfile[];
}
export interface SearchQueryBreakdown {
    advance: long;
    advance_count: long;
    build_scorer: long;
    build_scorer_count: long;
    create_weight: long;
    create_weight_count: long;
    match: long;
    match_count: long;
    shallow_advance: long;
    shallow_advance_count: long;
    next_doc: long;
    next_doc_count: long;
    score: long;
    score_count: long;
    compute_max_score: long;
    compute_max_score_count: long;
    set_min_competitive_score: long;
    set_min_competitive_score_count: long;
}
export interface SearchQueryProfile {
    breakdown: SearchQueryBreakdown;
    description: string;
    time_in_nanos: long;
    type: string;
    children?: SearchQueryProfile[];
}
export interface SearchRescore {
    query: SearchRescoreQuery;
    window_size?: integer;
}
export interface SearchRescoreQuery {
    rescore_query: QueryDslQueryContainer;
    query_weight?: double;
    rescore_query_weight?: double;
    score_mode?: SearchScoreMode;
}
export declare type SearchScoreMode = 'avg' | 'max' | 'min' | 'multiply' | 'total';
export interface SearchSearchProfile {
    collector: SearchCollector[];
    query: SearchQueryProfile[];
    rewrite_time: long;
}
export interface SearchShardProfile {
    aggregations: SearchAggregationProfile[];
    id: string;
    searches: SearchSearchProfile[];
    fetch?: SearchFetchProfile;
}
export interface SearchSmoothingModelContainer {
    laplace?: SearchLaplaceSmoothingModel;
    linear_interpolation?: SearchLinearInterpolationSmoothingModel;
    stupid_backoff?: SearchStupidBackoffSmoothingModel;
}
export declare type SearchSourceConfig = boolean | SearchSourceFilter | Fields;
export declare type SearchSourceConfigParam = boolean | Fields;
export interface SearchSourceFilter {
    excludes?: Fields;
    exclude?: Fields;
    includes?: Fields;
    include?: Fields;
}
export declare type SearchStringDistance = 'internal' | 'damerau_levenshtein' | 'levenshtein' | 'jaro_winkler' | 'ngram';
export interface SearchStupidBackoffSmoothingModel {
    discount: double;
}
export declare type SearchSuggest<TDocument = unknown> = SearchCompletionSuggest<TDocument> | SearchPhraseSuggest | SearchTermSuggest;
export interface SearchSuggestBase {
    length: integer;
    offset: integer;
    text: string;
}
export interface SearchSuggestFuzziness {
    fuzziness: Fuzziness;
    min_length: integer;
    prefix_length: integer;
    transpositions: boolean;
    unicode_aware: boolean;
}
export declare type SearchSuggestSort = 'score' | 'frequency';
export interface SearchSuggesterKeys {
    text?: string;
}
export declare type SearchSuggester = SearchSuggesterKeys & {
    [property: string]: SearchFieldSuggester | string;
};
export interface SearchSuggesterBase {
    field: Field;
    analyzer?: string;
    size?: integer;
}
export interface SearchTermSuggest extends SearchSuggestBase {
    options: SearchTermSuggestOption;
}
export interface SearchTermSuggestOption {
    text: string;
    freq: long;
    score: double;
}
export interface SearchTermSuggester extends SearchSuggesterBase {
    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?: SearchSuggestSort;
    string_distance?: SearchStringDistance;
    suggest_mode?: SuggestMode;
    text?: string;
}
export interface SearchTotalHits {
    relation: SearchTotalHitsRelation;
    value: long;
}
export declare type SearchTotalHitsRelation = 'eq' | 'gte';
export declare type SearchTrackHits = boolean | integer;
export interface SearchMvtRequest extends RequestBase {
    index: Indices;
    field: Field;
    zoom: SearchMvtZoomLevel;
    x: SearchMvtCoordinate;
    y: SearchMvtCoordinate;
    exact_bounds?: boolean;
    extent?: integer;
    grid_precision?: integer;
    grid_type?: SearchMvtGridType;
    size?: integer;
    aggs?: Record<string, AggregationsAggregationContainer>;
    fields?: Fields;
    query?: QueryDslQueryContainer;
    runtime_mappings?: MappingRuntimeFields;
    sort?: Sort;
    track_total_hits?: SearchTrackHits;
}
export declare type SearchMvtResponse = MapboxVectorTiles;
export declare type SearchMvtCoordinate = integer;
export declare type SearchMvtGridType = 'grid' | 'point' | 'centroid';
export declare type SearchMvtZoomLevel = integer;
export interface SearchShardsRequest extends RequestBase {
    index?: Indices;
    allow_no_indices?: boolean;
    expand_wildcards?: ExpandWildcards;
    ignore_unavailable?: boolean;
    local?: boolean;
    preference?: string;
    routing?: Routing;
}
export interface SearchShardsResponse {
    nodes: Record<string, NodeAttributes>;
    shards: NodeShard[][];
    indices: Record<IndexName, SearchShardsShardStoreIndex>;
}
export interface SearchShardsShardStoreIndex {
    aliases?: Name[];
    filter?: QueryDslQueryContainer;
}
export interface SearchTemplateRequest extends RequestBase {
    index?: Indices;
    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;
    rest_total_hits_as_int?: boolean;
    typed_keys?: boolean;
    id?: Id;
    params?: Record<string, any>;
    source?: string;
}
export interface SearchTemplateResponse<TDocument = unknown> {
    took: long;
    timed_out: boolean;
    _shards: ShardStatistics;
    hits: SearchHitsMetadata<TDocument>;
    aggregations?: Record<AggregateName, AggregationsAggregate>;
    _clusters?: ClusterStatistics;
    fields?: Record<string, any>;
    max_score?: double;
    num_reduce_phases?: long;
    profile?: SearchProfile;
    pit_id?: Id;
    _scroll_id?: ScrollId;
    suggest?: Record<SuggestionName, SearchSuggest<TDocument>[]>;
    terminated_early?: boolean;
}
export interface TermsEnumRequest extends RequestBase {
    index: IndexName;
    field: Field;
    size?: integer;
    timeout?: Time;
    case_insensitive?: boolean;
    index_filter?: QueryDslQueryContainer;
    string?: string;
    search_after?: string;
}
export interface TermsEnumResponse {
    _shards: ShardStatistics;
    terms: string[];
    complete: boolean;
}
export interface TermvectorsFieldStatistics {
    doc_count: integer;
    sum_doc_freq: long;
    sum_ttf: long;
}
export interface TermvectorsFilter {
    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 TermvectorsRequest<TDocument = unknown> extends RequestBase {
    index: IndexName;
    id?: Id;
    fields?: Fields;
    field_statistics?: boolean;
    offsets?: boolean;
    payloads?: boolean;
    positions?: boolean;
    preference?: string;
    realtime?: boolean;
    routing?: Routing;
    term_statistics?: boolean;
    version?: VersionNumber;
    version_type?: VersionType;
    doc?: TDocument;
    filter?: TermvectorsFilter;
    per_field_analyzer?: Record<Field, string>;
}
export interface TermvectorsResponse {
    found: boolean;
    _id: Id;
    _index: IndexName;
    term_vectors?: Record<Field, TermvectorsTermVector>;
    took: long;
    _version: VersionNumber;
}
export interface TermvectorsTerm {
    doc_freq?: integer;
    score?: double;
    term_freq: integer;
    tokens: TermvectorsToken[];
    ttf?: integer;
}
export interface TermvectorsTermVector {
    field_statistics: TermvectorsFieldStatistics;
    terms: Record<string, TermvectorsTerm>;
}
export interface TermvectorsToken {
    end_offset?: integer;
    payload?: string;
    position: integer;
    start_offset?: integer;
}
export interface UpdateRequest<TDocument = unknown, TPartialDocument = unknown> extends RequestBase {
    id: Id;
    index: IndexName;
    if_primary_term?: long;
    if_seq_no?: SequenceNumber;
    lang?: string;
    refresh?: Refresh;
    require_alias?: boolean;
    retry_on_conflict?: integer;
    routing?: Routing;
    timeout?: Time;
    wait_for_active_shards?: WaitForActiveShards;
    _source?: SearchSourceConfigParam;
    _source_excludes?: Fields;
    _source_includes?: Fields;
    detect_noop?: boolean;
    doc?: TPartialDocument;
    doc_as_upsert?: boolean;
    script?: Script;
    scripted_upsert?: boolean;
    upsert?: TDocument;
}
export declare type UpdateResponse<TDocument = unknown> = UpdateUpdateWriteResponseBase<TDocument>;
export interface UpdateUpdateWriteResponseBase<TDocument = unknown> extends WriteResponseBase {
    get?: InlineGet<TDocument>;
}
export interface UpdateByQueryRequest extends RequestBase {
    index: Indices;
    allow_no_indices?: boolean;
    analyzer?: string;
    analyze_wildcard?: boolean;
    conflicts?: Conflicts;
    default_operator?: QueryDslOperator;
    df?: string;
    expand_wildcards?: ExpandWildcards;
    from?: long;
    ignore_unavailable?: boolean;
    lenient?: boolean;
    max_docs?: long;
    pipeline?: string;
    preference?: string;
    refresh?: boolean;
    request_cache?: boolean;
    requests_per_second?: long;
    routing?: Routing;
    scroll?: Time;
    scroll_size?: long;
    search_timeout?: Time;
    search_type?: SearchType;
    slices?: long;
    sort?: string[];
    stats?: string[];
    terminate_after?: long;
    timeout?: Time;
    version?: boolean;
    version_type?: boolean;
    wait_for_active_shards?: WaitForActiveShards;
    wait_for_completion?: boolean;
    query?: QueryDslQueryContainer;
    script?: Script;
    slice?: SlicedScroll;
}
export interface UpdateByQueryResponse {
    batches?: long;
    failures?: BulkIndexByScrollFailure[];
    noops?: long;
    deleted?: long;
    requests_per_second?: float;
    retries?: Retries;
    task?: TaskId;
    timed_out?: boolean;
    took?: long;
    total?: long;
    updated?: long;
    version_conflicts?: long;
    throttled_millis?: ulong;
    throttled_until_millis?: ulong;
}
export interface UpdateByQueryRethrottleRequest extends RequestBase {
    task_id: Id;
    requests_per_second?: long;
}
export interface UpdateByQueryRethrottleResponse {
    nodes: Record<string, UpdateByQueryRethrottleUpdateByQueryRethrottleNode>;
}
export interface UpdateByQueryRethrottleUpdateByQueryRethrottleNode extends SpecUtilsBaseNode {
    tasks: Record<TaskId, TasksTaskInfo>;
}
export interface SpecUtilsBaseNode {
    attributes: Record<string, string>;
    host: Host;
    ip: Ip;
    name: Name;
    roles?: NodeRoles;
    transport_address: TransportAddress;
}
export interface AcknowledgedResponseBase {
    acknowledged: boolean;
}
export declare type AggregateName = string;
export interface BulkIndexByScrollFailure {
    cause: ErrorCause;
    id: Id;
    index: IndexName;
    status: integer;
    type: string;
}
export interface BulkStats {
    total_operations: long;
    total_time?: string;
    total_time_in_millis: long;
    total_size?: ByteSize;
    total_size_in_bytes: long;
    avg_time?: string;
    avg_time_in_millis: long;
    avg_size?: ByteSize;
    avg_size_in_bytes: long;
}
export declare type ByteSize = long | string;
export declare type Bytes = 'b' | 'kb' | 'mb' | 'gb' | 'tb' | 'pb';
export declare type CategoryId = string;
export interface ClusterStatistics {
    skipped: integer;
    successful: integer;
    total: integer;
}
export interface CompletionStats {
    size_in_bytes: long;
    size?: ByteSize;
    fields?: Record<Field, FieldSizeUsage>;
}
export declare type Conflicts = 'abort' | 'proceed';
export interface CoordsGeoBounds {
    top: double;
    bottom: double;
    left: double;
    right: double;
}
export declare type DFIIndependenceMeasure = 'standardized' | 'saturated' | 'chisquared';
export declare type DFRAfterEffect = 'no' | 'b' | 'l';
export declare type DFRBasicModel = 'be' | 'd' | 'g' | 'if' | 'in' | 'ine' | 'p';
export declare type DataStreamName = string;
export declare type DataStreamNames = DataStreamName | DataStreamName[];
export declare type DateFormat = string;
export declare type DateMath = string;
export declare type DateMathTime = string;
export declare type DateOrEpochMillis = DateString | EpochMillis;
export declare type DateString = string;
export declare type Distance = string;
export declare type DistanceUnit = 'in' | 'ft' | 'yd' | 'mi' | 'nmi' | 'km' | 'm' | 'cm' | 'mm';
export interface DocStats {
    count: long;
    deleted?: long;
}
export interface ElasticsearchVersionInfo {
    build_date: DateString;
    build_flavor: string;
    build_hash: string;
    build_snapshot: boolean;
    build_type: string;
    lucene_version: VersionString;
    minimum_index_compatibility_version: VersionString;
    minimum_wire_compatibility_version: VersionString;
    number: string;
}
export interface EmptyObject {
}
export declare type EpochMillis = string | long;
export interface ErrorCauseKeys {
    type: string;
    reason: string;
    stack_trace?: string;
    caused_by?: ErrorCause;
    root_cause?: ErrorCause[];
    suppressed?: ErrorCause[];
}
export declare type ErrorCause = ErrorCauseKeys & {
    [property: string]: any;
};
export interface ErrorResponseBase {
    error: ErrorCause;
    status: integer;
}
export declare type ExpandWildcard = 'all' | 'open' | 'closed' | 'hidden' | 'none';
export declare type ExpandWildcards = ExpandWildcard | ExpandWildcard[];
export declare type Field = string;
export interface FieldMemoryUsage {
    memory_size?: ByteSize;
    memory_size_in_bytes: long;
}
export interface FieldSizeUsage {
    size?: ByteSize;
    size_in_bytes: long;
}
export interface FieldSort {
    missing?: AggregationsMissing;
    mode?: SortMode;
    nested?: NestedSortValue;
    order?: SortOrder;
    unmapped_type?: MappingFieldType;
    numeric_type?: FieldSortNumericType;
    format?: string;
}
export declare type FieldSortNumericType = 'long' | 'double' | 'date' | 'date_nanos';
export declare type FieldValue = long | double | string | boolean;
export interface FielddataStats {
    evictions?: long;
    memory_size?: ByteSize;
    memory_size_in_bytes: long;
    fields?: Record<Field, FieldMemoryUsage>;
}
export declare type Fields = Field | Field[];
export interface FlushStats {
    periodic: long;
    total: long;
    total_time?: string;
    total_time_in_millis: long;
}
export declare type Fuzziness = string | integer;
export declare type GeoBounds = CoordsGeoBounds | TopLeftBottomRightGeoBounds | TopRightBottomLeftGeoBounds | WktGeoBounds;
export interface GeoDistanceSort