@terascope/types 0.10.2 → 0.11.0

package/dist/src/elasticsearch-client/elasticsearch-types.d.ts

@@ -0,0 +1,2148 @@
+export declare type Duration = number;
+export declare type TimeUnit = 'd' | 'h' | 'm' | 's' | 'ms' | 'micros' | 'nanos';
+export declare type TimeSpan = `${Duration}${TimeUnit}`;
+export declare type ExpandWildcards = 'open' | 'closed' | 'hidden' | 'none' | 'all';
+export declare type SearchTypes = 'query_then_fetch' | 'dfs_query_then_fetch';
+export declare type SuggestMode = 'missing' | 'popular' | 'always';
+export declare type ConflictOptions = 'abort' | 'proceed';
+export declare type ScriptLangs = 'painless' | 'expression' | 'mustache' | 'java';
+export declare type Health = 'green' | 'yellow' | 'red';
+export declare type Bytes = 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
+export interface Remote {
+    host?: string;
+    username?: string;
+    password?: string;
+    socket_timeout?: TimeSpan;
+    connect_timeout?: TimeSpan;
+}
+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 BulkIndexByScrollFailure {
+    cause: ErrorCause;
+    id: string;
+    index: string;
+    status: number;
+    type: string;
+}
+export interface SearchResult<TDocument = Record<string, any>> {
+    fields?: Record<string, any>;
+    found: boolean;
+    _index: string;
+    _type?: string;
+    _score?: number;
+    _id: string;
+    _primary_term?: number;
+    _routing?: string;
+    _seq_no?: number;
+    _source?: TDocument;
+    _version?: number;
+}
+export interface ShardFailure {
+    index?: string;
+    node?: string;
+    reason: ErrorCause;
+    shard: number;
+    status?: string;
+}
+export declare type IndexRefresh = boolean | RefreshOptions;
+export declare type RefreshOptions = 'wait_for';
+export declare type VersionType = 'internal' | 'external' | 'external_gte' | 'force';
+export declare type Action = 'Error' | 'created' | 'updated' | 'deleted' | 'not_found' | 'noop';
+export interface ShardStatistics {
+    failed: number;
+    successful: number;
+    total: number;
+    failures?: ShardFailure[];
+    skipped?: number;
+}
+export interface WriteResponseBase {
+    _id: string;
+    _index: string;
+    _primary_term: number;
+    result: Action;
+    _seq_no: number;
+    _shards: ShardStatistics;
+    _version: number;
+    forced_refresh?: boolean;
+    error?: ErrorCauseKeys;
+}
+export declare type WaitForActiveShardOptions = 'all';
+export declare type WaitForActiveShards = number | WaitForActiveShardOptions;
+export declare type OpType = 'index' | 'create';
+export declare type ScriptLanguage = 'painless' | 'expression' | 'mustache' | 'java';
+export interface IndexedScript extends ScriptBase {
+    id: string;
+}
+export interface ScriptBase {
+    lang?: ScriptLanguage;
+    params?: Record<string, any>;
+}
+export interface InlineScript extends ScriptBase {
+    source: string;
+}
+export declare type Script = InlineScript | IndexedScript | string;
+export interface SearchSourceFilter {
+    excludes?: string | string[];
+    includes?: string | string[];
+    exclude?: string | string[];
+    include?: string | string[];
+}
+export interface InlineGet<TDocument = unknown> {
+    fields?: Record<string, any>;
+    found: boolean;
+    _seq_no: number;
+    _primary_term: number;
+    _routing?: string;
+    _source: TDocument;
+}
+export interface PluginStats {
+    classname: string;
+    description: string;
+    opensearch_version: string;
+    extended_plugins: string[];
+    has_native_controller: boolean;
+    java_version: string;
+    name: string;
+    version: string;
+    licensed: boolean;
+    type: string;
+}
+export declare type NodeRole = 'cluster_manager' | 'master' | 'data' | 'client' | 'ingest' | 'voting_only' | 'remote_cluster_client' | 'coordinating_only';
+export declare type NodeRoles = NodeRole[];
+export interface IndexTemplateProperties {
+    aliases?: {
+        [alias: string]: Alias;
+    };
+    mappings?: Record<string, any>;
+    settings?: Record<string, any>;
+    index_patterns?: string | string[];
+}
+export interface Alias {
+    filter?: string;
+    index_routing?: string;
+    is_hidden?: boolean;
+    is_write_index?: boolean;
+    routing?: string;
+    search_routing?: string;
+}
+export interface MGetBody {
+    docs?: MGetDocs[];
+    ids?: string[];
+}
+export interface MGetDocs {
+    _id: string;
+    _index?: string;
+    _type?: string;
+    _source?: boolean;
+    routing?: string;
+    source_includes?: string | string[];
+    source_excludes?: string | string[];
+    _stored_fields?: string | string[];
+}
+export declare type BulkCreateOperation = BulkOperation;
+export declare type BulkCreateResponseItem = BulkResponseItemBase;
+export declare type BulkDeleteOperation = BulkOperation;
+export declare type BulkDeleteResponseItem = BulkResponseItemBase;
+export declare type BulkIndexOperation = BulkOperation;
+export declare type BulkIndexResponseItem = BulkResponseItemBase;
+export interface BulkOperation {
+    _id: string;
+    _index: string;
+    retry_on_conflict: number;
+    routing: string;
+    version: number;
+    version_type: VersionType;
+}
+export interface BulkOperationContainer {
+    index?: BulkIndexOperation;
+    create?: BulkCreateOperation;
+    update?: BulkUpdateOperation;
+    delete?: BulkDeleteOperation;
+}
+export declare type SearchSourceConfig = boolean | SearchSourceFilter | string | string[];
+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 BulkResponseItemBase {
+    _id?: string | null;
+    _index: string;
+    status: number;
+    error?: ErrorCause;
+    _primary_term?: number;
+    result?: string;
+    _seq_no?: number;
+    _shards?: ShardStatistics;
+    _version?: number;
+    forced_refresh?: boolean;
+    get?: InlineGet<Record<string, any>>;
+}
+export interface BulkResponseItemContainer {
+    index?: BulkIndexResponseItem;
+    create?: BulkCreateResponseItem;
+    update?: BulkUpdateResponseItem;
+    delete?: BulkDeleteResponseItem;
+}
+export declare type BulkUpdateOperation = BulkOperation;
+export declare type BulkUpdateResponseItem = BulkResponseItemBase;
+export interface CatIndicesIndicesRecord {
+    health?: string;
+    h?: string;
+    status?: string;
+    s?: string;
+    index?: string;
+    i?: string;
+    idx?: string;
+    uuid?: string;
+    id?: string;
+    pri?: string;
+    p?: string;
+    'shards.primary'?: string;
+    shardsPrimary?: string;
+    rep?: string;
+    r?: string;
+    'shards.replica'?: string;
+    shardsReplica?: string;
+    'docs.count'?: string;
+    dc?: string;
+    docsCount?: string;
+    'docs.deleted'?: string;
+    dd?: string;
+    docsDeleted?: string;
+    'creation.date'?: string;
+    cd?: string;
+    'creation.date.string'?: string;
+    cds?: string;
+    'store.size'?: string;
+    ss?: string;
+    storeSize?: string;
+    'prstore.size'?: string;
+    'completion.size'?: string;
+    cs?: string;
+    completionSize?: string;
+    'prcompletion.size'?: string;
+    'fielddata.memory_size'?: string;
+    fm?: string;
+    fielddataMemory?: string;
+    'prfielddata.memory_size'?: string;
+    'fielddata.evictions'?: string;
+    fe?: string;
+    fielddataEvictions?: string;
+    'prfielddata.evictions'?: string;
+    'query_cache.memory_size'?: string;
+    qcm?: string;
+    queryCacheMemory?: string;
+    'prquery_cache.memory_size'?: string;
+    'query_cache.evictions'?: string;
+    qce?: string;
+    queryCacheEvictions?: string;
+    'prquery_cache.evictions'?: string;
+    'request_cache.memory_size'?: string;
+    rcm?: string;
+    requestCacheMemory?: string;
+    'prrequest_cache.memory_size'?: string;
+    'request_cache.evictions'?: string;
+    rce?: string;
+    requestCacheEvictions?: string;
+    'prrequest_cache.evictions'?: string;
+    'request_cache.hit_count'?: string;
+    rchc?: string;
+    requestCacheHitCount?: string;
+    'prrequest_cache.hit_count'?: string;
+    'request_cache.miss_count'?: string;
+    rcmc?: string;
+    requestCacheMissCount?: string;
+    'prrequest_cache.miss_count'?: string;
+    'flush.total'?: string;
+    ft?: string;
+    flushTotal?: string;
+    'prflush.total'?: string;
+    'flush.total_time'?: string;
+    ftt?: string;
+    flushTotalTime?: string;
+    'prflush.total_time'?: string;
+    'get.current'?: string;
+    gc?: string;
+    getCurrent?: string;
+    'prget.current'?: string;
+    'get.time'?: string;
+    gti?: string;
+    getTime?: string;
+    'prget.time'?: string;
+    'get.total'?: string;
+    gto?: string;
+    getTotal?: string;
+    'prget.total'?: string;
+    'get.exists_time'?: string;
+    geti?: string;
+    getExistsTime?: string;
+    'prget.exists_time'?: string;
+    'get.exists_total'?: string;
+    geto?: string;
+    getExistsTotal?: string;
+    'prget.exists_total'?: string;
+    'get.missing_time'?: string;
+    gmti?: string;
+    getMissingTime?: string;
+    'prget.missing_time'?: string;
+    'get.missing_total'?: string;
+    gmto?: string;
+    getMissingTotal?: string;
+    'prget.missing_total'?: string;
+    'indexing.delete_current'?: string;
+    idc?: string;
+    indexingDeleteCurrent?: string;
+    'prindexing.delete_current'?: string;
+    'indexing.delete_time'?: string;
+    idti?: string;
+    indexingDeleteTime?: string;
+    'prindexing.delete_time'?: string;
+    'indexing.delete_total'?: string;
+    idto?: string;
+    indexingDeleteTotal?: string;
+    'prindexing.delete_total'?: string;
+    'indexing.index_current'?: string;
+    iic?: string;
+    indexingIndexCurrent?: string;
+    'prindexing.index_current'?: string;
+    'indexing.index_time'?: string;
+    iiti?: string;
+    indexingIndexTime?: string;
+    'prindexing.index_time'?: string;
+    'indexing.index_total'?: string;
+    iito?: string;
+    indexingIndexTotal?: string;
+    'prindexing.index_total'?: string;
+    'indexing.index_failed'?: string;
+    iif?: string;
+    indexingIndexFailed?: string;
+    'prindexing.index_failed'?: string;
+    'merges.current'?: string;
+    mc?: string;
+    mergesCurrent?: string;
+    'prmerges.current'?: string;
+    'merges.current_docs'?: string;
+    mcd?: string;
+    mergesCurrentDocs?: string;
+    'prmerges.current_docs'?: string;
+    'merges.current_size'?: string;
+    mcs?: string;
+    mergesCurrentSize?: string;
+    'prmerges.current_size'?: string;
+    'merges.total'?: string;
+    mt?: string;
+    mergesTotal?: string;
+    'prmerges.total'?: string;
+    'merges.total_docs'?: string;
+    mtd?: string;
+    mergesTotalDocs?: string;
+    'prmerges.total_docs'?: string;
+    'merges.total_size'?: string;
+    mts?: string;
+    mergesTotalSize?: string;
+    'prmerges.total_size'?: string;
+    'merges.total_time'?: string;
+    mtt?: string;
+    mergesTotalTime?: string;
+    'prmerges.total_time'?: string;
+    'refresh.total'?: string;
+    rto?: string;
+    refreshTotal?: string;
+    'prrefresh.total'?: string;
+    'refresh.time'?: string;
+    rti?: string;
+    refreshTime?: string;
+    'prrefresh.time'?: string;
+    'refresh.external_total'?: string;
+    reto?: string;
+    'prrefresh.external_total'?: string;
+    'refresh.external_time'?: string;
+    reti?: string;
+    'prrefresh.external_time'?: string;
+    'refresh.listeners'?: string;
+    rli?: string;
+    refreshListeners?: string;
+    'prrefresh.listeners'?: string;
+    'search.fetch_current'?: string;
+    sfc?: string;
+    searchFetchCurrent?: string;
+    'prsearch.fetch_current'?: string;
+    'search.fetch_time'?: string;
+    sfti?: string;
+    searchFetchTime?: string;
+    'prsearch.fetch_time'?: string;
+    'search.fetch_total'?: string;
+    sfto?: string;
+    searchFetchTotal?: string;
+    'prsearch.fetch_total'?: string;
+    'search.open_contexts'?: string;
+    so?: string;
+    searchOpenContexts?: string;
+    'prsearch.open_contexts'?: string;
+    'search.query_current'?: string;
+    sqc?: string;
+    searchQueryCurrent?: string;
+    'prsearch.query_current'?: string;
+    'search.query_time'?: string;
+    sqti?: string;
+    searchQueryTime?: string;
+    'prsearch.query_time'?: string;
+    'search.query_total'?: string;
+    sqto?: string;
+    searchQueryTotal?: string;
+    'prsearch.query_total'?: string;
+    'search.scroll_current'?: string;
+    scc?: string;
+    searchScrollCurrent?: string;
+    'prsearch.scroll_current'?: string;
+    'search.scroll_time'?: string;
+    scti?: string;
+    searchScrollTime?: string;
+    'prsearch.scroll_time'?: string;
+    'search.scroll_total'?: string;
+    scto?: string;
+    searchScrollTotal?: string;
+    'prsearch.scroll_total'?: string;
+    'segments.count'?: string;
+    sc?: string;
+    segmentsCount?: string;
+    'prsegments.count'?: string;
+    'segments.memory'?: string;
+    sm?: string;
+    segmentsMemory?: string;
+    'prsegments.memory'?: string;
+    'segments.index_writer_memory'?: string;
+    siwm?: string;
+    segmentsIndexWriterMemory?: string;
+    'prsegments.index_writer_memory'?: string;
+    'segments.version_map_memory'?: string;
+    svmm?: string;
+    segmentsVersionMapMemory?: string;
+    'prsegments.version_map_memory'?: string;
+    'segments.fixed_bitset_memory'?: string;
+    sfbm?: string;
+    fixedBitsetMemory?: string;
+    'prsegments.fixed_bitset_memory'?: string;
+    'warmer.current'?: string;
+    wc?: string;
+    warmerCurrent?: string;
+    'prwarmer.current'?: string;
+    'warmer.total'?: string;
+    wto?: string;
+    warmerTotal?: string;
+    'prwarmer.total'?: string;
+    'warmer.total_time'?: string;
+    wtt?: string;
+    warmerTotalTime?: string;
+    'prwarmer.total_time'?: string;
+    'suggest.current'?: string;
+    suc?: string;
+    suggestCurrent?: string;
+    'prsuggest.current'?: string;
+    'suggest.time'?: string;
+    suti?: string;
+    suggestTime?: string;
+    'prsuggest.time'?: string;
+    'suggest.total'?: string;
+    suto?: string;
+    suggestTotal?: string;
+    'prsuggest.total'?: string;
+    'memory.total'?: string;
+    tm?: string;
+    memoryTotal?: string;
+    'prmemory.total'?: string;
+    'search.throttled'?: string;
+    sth?: string;
+    'bulk.total_operations'?: string;
+    bto?: string;
+    bulkTotalOperation?: string;
+    'prbulk.total_operations'?: string;
+    'bulk.total_time'?: string;
+    btti?: string;
+    bulkTotalTime?: string;
+    'prbulk.total_time'?: string;
+    'bulk.total_size_in_bytes'?: string;
+    btsi?: string;
+    bulkTotalSizeInBytes?: string;
+    'prbulk.total_size_in_bytes'?: string;
+    'bulk.avg_time'?: string;
+    bati?: string;
+    bulkAvgTime?: string;
+    'prbulk.avg_time'?: string;
+    'bulk.avg_size_in_bytes'?: string;
+    basi?: string;
+    bulkAvgSizeInBytes?: string;
+    'prbulk.avg_size_in_bytes'?: string;
+}
+export interface ClusterHealthShardHealthStats {
+    active_shards: number;
+    initializing_shards: number;
+    primary_active: boolean;
+    relocating_shards: number;
+    status: Health;
+    unassigned_shards: number;
+}
+export interface ClusterHealthIndexHealthStats {
+    active_primary_shards: number;
+    active_shards: number;
+    initializing_shards: number;
+    number_of_replicas: number;
+    number_of_shards: number;
+    relocating_shards: number;
+    shards?: Record<string, ClusterHealthShardHealthStats>;
+    status: Health;
+    unassigned_shards: number;
+}
+export interface IndicesGetFieldMappingTypeFieldMappings {
+    mappings: Partial<Record<string, MappingFieldMapping>>;
+}
+export interface MappingFieldMapping {
+    full_name: string;
+    mapping: Partial<Record<string, MappingProperty>>;
+}
+export interface IndexTemplate {
+    name: string;
+    index_template: {
+        index_patterns: string[];
+        settings: {
+            index: Record<string, any>;
+        };
+        mappings: Record<string, any>;
+        aliases: Alias;
+    };
+}
+export interface IndicesGetMappingIndexMappingRecord {
+    item?: MappingTypeMapping;
+    mappings: MappingTypeMapping;
+}
+export interface IndicesIndexState {
+    aliases?: Record<string, IndicesAlias>;
+    mappings?: MappingTypeMapping;
+    settings: IndicesIndexSettings | IndicesIndexStatePrefixedSettings;
+}
+export interface MappingTypeMapping {
+    all_field?: MappingAllField;
+    date_detection?: boolean;
+    dynamic?: boolean | MappingDynamicMapping;
+    dynamic_date_formats?: string[];
+    dynamic_templates?: Record<string, MappingDynamicTemplate> | Record<string, MappingDynamicTemplate>[];
+    _field_names?: {
+        enabled: boolean;
+    };
+    index_field?: {
+        enabled: boolean;
+    };
+    _meta?: Record<string, unknown>;
+    numeric_detection?: boolean;
+    properties?: Record<string, MappingProperty>;
+    _routing?: {
+        required: boolean;
+    };
+    _size?: {
+        enabled: boolean;
+    };
+    _source?: {
+        compress?: boolean;
+        compress_threshold?: string;
+        enabled: boolean;
+        excludes?: string[];
+        includes?: string[];
+    };
+    runtime?: Record<string, MappingRuntimeField>;
+}
+export interface MappingRuntimeField {
+    format?: string;
+    script?: Script;
+    type: MappingRuntimeFieldType;
+}
+export declare type MappingRuntimeFieldType = 'boolean' | 'date' | 'number' | 'geo_point' | 'ip' | 'keyword' | 'long';
+export interface MappingDynamicTemplate {
+    mapping?: MappingPropertyBase;
+    match?: string;
+    match_mapping_type?: string;
+    match_pattern?: MappingMatchType;
+    path_match?: string;
+    path_unmatch?: string;
+    unmatch?: string;
+}
+export interface MappingPropertyBase {
+    local_metadata?: Record<string, any>;
+    meta?: Record<string, string>;
+    name?: string;
+    properties?: Record<string, MappingProperty>;
+    ignore_above?: number;
+    dynamic?: boolean | MappingDynamicMapping;
+    fields?: Record<string, MappingProperty>;
+}
+export declare type MappingProperty = MappingFlattenedProperty | MappingJoinProperty | MappingPercolatorProperty | MappingRankFeatureProperty | MappingRankFeaturesProperty | MappingConstantKeywordProperty | MappingFieldAliasProperty | MappingHistogramProperty | MappingCoreProperty;
+export interface MappingFlattenedProperty extends MappingPropertyBase {
+    boost?: number;
+    depth_limit?: number;
+    doc_values?: boolean;
+    eager_global_ordinals?: boolean;
+    index?: boolean;
+    index_options?: MappingIndexOptions;
+    null_value?: string;
+    similarity?: string;
+    split_queries_on_whitespace?: boolean;
+    type: 'flattened';
+}
+export declare type MappingCoreProperty = MappingObjectProperty | MappingNestedProperty | MappingSearchAsYouTypeProperty | MappingTextProperty | MappingDocValuesProperty;
+export declare type MappingDocValuesProperty = MappingBinaryProperty | MappingBooleanProperty | MappingDateProperty | MappingDateNanosProperty | MappingKeywordProperty | MappingNumberProperty | MappingRangeProperty | MappingGeoPointProperty | MappingGeoShapeProperty | MappingCompletionProperty | MappingIpProperty | MappingMurmur3HashProperty | MappingShapeProperty | MappingTokenCountProperty | MappingVersionProperty | MappingWildcardProperty | MappingPointProperty;
+export interface MappingBooleanProperty extends MappingDocValuesPropertyBase {
+    boost?: number;
+    fielddata?: IndicesNumericFielddata;
+    index?: boolean;
+    null_value?: boolean;
+    type: 'boolean';
+}
+export interface IndicesNumericFielddata {
+    format: IndicesNumericFielddataFormat;
+}
+export declare type IndicesNumericFielddataFormat = 'array' | 'disabled';
+export interface MappingPointProperty extends MappingDocValuesPropertyBase {
+    ignore_malformed?: boolean;
+    ignore_z_value?: boolean;
+    null_value?: string;
+    type: 'point';
+}
+export interface MappingWildcardProperty extends MappingDocValuesPropertyBase {
+    type: 'wildcard';
+    null_value?: string;
+}
+export interface MappingVersionProperty extends MappingDocValuesPropertyBase {
+    type: 'version';
+}
+export interface MappingTokenCountProperty extends MappingDocValuesPropertyBase {
+    analyzer?: string;
+    boost?: number;
+    index?: boolean;
+    null_value?: number;
+    enable_position_increments?: boolean;
+    type: 'token_count';
+}
+export interface MappingShapeProperty extends MappingDocValuesPropertyBase {
+    coerce?: boolean;
+    ignore_malformed?: boolean;
+    ignore_z_value?: boolean;
+    orientation?: MappingGeoOrientation;
+    type: 'shape';
+}
+export declare type MappingGeoOrientation = 'right' | 'RIGHT' | 'counterclockwise' | 'ccw' | 'left' | 'LEFT' | 'clockwise' | 'cw';
+export interface MappingMurmur3HashProperty extends MappingDocValuesPropertyBase {
+    type: 'murmur3';
+}
+export interface MappingIpProperty extends MappingDocValuesPropertyBase {
+    boost?: number;
+    index?: boolean;
+    null_value?: string;
+    ignore_malformed?: boolean;
+    type: 'ip';
+}
+export interface MappingCompletionProperty extends MappingDocValuesPropertyBase {
+    analyzer?: string;
+    contexts?: MappingSuggestContext[];
+    max_input_length?: number;
+    preserve_position_increments?: boolean;
+    preserve_separators?: boolean;
+    search_analyzer?: string;
+    type: 'completion';
+}
+export interface MappingSuggestContext {
+    name: string;
+    path?: string;
+    type: string;
+    precision?: number | string;
+}
+export declare type MappingGeoStrategy = 'recursive' | 'term';
+export interface MappingGeoShapeProperty extends MappingDocValuesPropertyBase {
+    coerce?: boolean;
+    ignore_malformed?: boolean;
+    ignore_z_value?: boolean;
+    orientation?: MappingGeoOrientation;
+    strategy?: MappingGeoStrategy;
+    type: 'geo_shape';
+}
+export interface MappingGeoPointProperty extends MappingDocValuesPropertyBase {
+    ignore_malformed?: boolean;
+    ignore_z_value?: boolean;
+    null_value?: GeoLocation;
+    type: 'geo_point';
+}
+export declare type GeoLocation = LatLonGeoLocation | GeoHashLocation | number[] | string;
+export interface LatLonGeoLocation {
+    lat: number;
+    lon: number;
+}
+export declare type GeoHash = string;
+export interface GeoHashLocation {
+    geohash: GeoHash;
+}
+export interface MappingLongRangeProperty extends MappingRangePropertyBase {
+    type: 'long_range';
+}
+export interface MappingIpRangeProperty extends MappingRangePropertyBase {
+    type: 'ip_range';
+}
+export interface MappingRangePropertyBase extends MappingDocValuesPropertyBase {
+    boost?: number;
+    coerce?: boolean;
+    index?: boolean;
+}
+export interface MappingIntegerRangeProperty extends MappingRangePropertyBase {
+    type: 'integer_range';
+}
+export interface MappingDoubleRangeProperty extends MappingRangePropertyBase {
+    type: 'double_range';
+}
+export declare type MappingRangeProperty = MappingLongRangeProperty | MappingIpRangeProperty | MappingIntegerRangeProperty | MappingFloatRangeProperty | MappingDoubleRangeProperty | MappingDateRangeProperty;
+export declare type MappingNumberProperty = MappingFloatNumberProperty | MappingHalfFloatNumberProperty | MappingDoubleNumberProperty | MappingIntegerNumberProperty | MappingLongNumberProperty | MappingShortNumberProperty | MappingByteNumberProperty | MappingUnsignedLongNumberProperty | MappingScaledFloatNumberProperty;
+export interface MappingFloatNumberProperty extends MappingStandardNumberProperty {
+    type: 'float';
+    null_value?: number;
+}
+export interface MappingNumberPropertyBase extends MappingDocValuesPropertyBase {
+    index?: boolean;
+    ignore_malformed?: boolean;
+    time_series_metric?: MappingTimeSeriesMetricType;
+}
+export declare type MappingTimeSeriesMetricType = 'gauge' | 'counter' | 'summary' | 'histogram';
+export interface MappingStandardNumberProperty extends MappingNumberPropertyBase {
+    coerce?: boolean;
+    script?: Script;
+    on_script_error?: MappingOnScriptError;
+}
+export declare type MappingOnScriptError = 'fail' | 'continue';
+export interface MappingScaledFloatNumberProperty extends MappingNumberPropertyBase {
+    type: 'scaled_float';
+    coerce?: boolean;
+    null_value?: number;
+    scaling_factor?: number;
+}
+export interface MappingUnsignedLongNumberProperty extends MappingNumberPropertyBase {
+    type: 'unsigned_long';
+    null_value?: number;
+}
+export interface MappingByteNumberProperty extends MappingStandardNumberProperty {
+    type: 'byte';
+    null_value?: number;
+}
+export interface MappingShortNumberProperty extends MappingStandardNumberProperty {
+    type: 'short';
+    null_value?: number;
+}
+export interface MappingLongNumberProperty extends MappingStandardNumberProperty {
+    type: 'long';
+    null_value?: number;
+}
+export interface MappingIntegerNumberProperty extends MappingStandardNumberProperty {
+    type: 'integer';
+    null_value?: number;
+}
+export interface MappingDoubleNumberProperty extends MappingStandardNumberProperty {
+    type: 'double';
+    null_value?: number;
+}
+export interface MappingHalfFloatNumberProperty extends MappingStandardNumberProperty {
+    type: 'half_float';
+    null_value?: number;
+}
+export interface MappingKeywordProperty extends MappingDocValuesPropertyBase {
+    boost?: number;
+    eager_global_ordinals?: boolean;
+    index?: boolean;
+    index_options?: MappingIndexOptions;
+    normalizer?: string;
+    norms?: boolean;
+    null_value?: string;
+    split_queries_on_whitespace?: boolean;
+    time_series_dimension?: boolean;
+    type: 'keyword';
+}
+export interface MappingDateNanosProperty extends MappingDocValuesPropertyBase {
+    boost?: number;
+    format?: string;
+    ignore_malformed?: boolean;
+    index?: boolean;
+    null_value?: string;
+    precision_step?: number;
+    type: 'date_nanos';
+}
+export interface MappingDateProperty extends MappingDocValuesPropertyBase {
+    boost?: number;
+    fielddata?: IndicesNumericFielddata;
+    format?: string;
+    ignore_malformed?: boolean;
+    index?: boolean;
+    null_value?: string;
+    precision_step?: number;
+    locale?: string;
+    type: 'date';
+}
+export interface MappingDateRangeProperty extends MappingRangePropertyBase {
+    format?: string;
+    type: 'date_range';
+}
+export interface MappingBinaryProperty extends MappingDocValuesPropertyBase {
+    type: 'binary';
+}
+export interface MappingObjectProperty extends MappingCorePropertyBase {
+    enabled?: boolean;
+    type?: 'object';
+}
+export interface MappingDocValuesPropertyBase extends MappingCorePropertyBase {
+    doc_values?: boolean;
+}
+export interface MappingTextProperty extends MappingCorePropertyBase {
+    analyzer?: string;
+    boost?: number;
+    eager_global_ordinals?: boolean;
+    fielddata?: boolean;
+    fielddata_frequency_filter?: IndicesFielddataFrequencyFilter;
+    index?: boolean;
+    index_options?: MappingIndexOptions;
+    index_phrases?: boolean;
+    index_prefixes?: MappingTextIndexPrefixes;
+    norms?: boolean;
+    position_increment_gap?: number;
+    search_analyzer?: string;
+    search_quote_analyzer?: string;
+    term_vector?: MappingTermVectorOption;
+    type: 'text';
+}
+export declare type MappingTermVectorOption = 'no' | 'yes' | 'with_offsets' | 'with_positions' | 'with_positions_offsets' | 'with_positions_offsets_payloads' | 'with_positions_payloads';
+export interface MappingTextIndexPrefixes {
+    max_chars: number;
+    min_chars: number;
+}
+export interface IndicesFielddataFrequencyFilter {
+    max: number;
+    min: number;
+    min_segment_size: number;
+}
+export interface MappingSearchAsYouTypeProperty extends MappingCorePropertyBase {
+    analyzer?: string;
+    index?: boolean;
+    index_options?: MappingIndexOptions;
+    max_shingle_size?: number;
+    norms?: boolean;
+    search_analyzer?: string;
+    search_quote_analyzer?: string;
+    term_vector?: MappingTermVectorOption;
+    type: 'search_as_you_type';
+}
+export interface MappingCorePropertyBase extends MappingPropertyBase {
+    copy_to?: string | string[];
+    similarity?: string;
+    store?: boolean;
+}
+export declare type MappingIndexOptions = 'docs' | 'freqs' | 'positions' | 'offsets';
+export interface MappingNestedProperty extends MappingCorePropertyBase {
+    enabled?: boolean;
+    include_in_parent?: boolean;
+    include_in_root?: boolean;
+    type: 'nested';
+}
+export interface MappingHistogramProperty extends MappingPropertyBase {
+    ignore_malformed?: boolean;
+    type: 'histogram';
+}
+export interface MappingFieldAliasProperty extends MappingPropertyBase {
+    path?: string;
+    type: 'alias';
+}
+export interface MappingConstantKeywordProperty extends MappingPropertyBase {
+    value?: any;
+    type: 'constant_keyword';
+}
+export interface MappingRankFeatureProperty extends MappingPropertyBase {
+    positive_score_impact?: boolean;
+    type: 'rank_feature';
+}
+export interface MappingRankFeaturesProperty extends MappingPropertyBase {
+    type: 'rank_features';
+}
+export interface MappingPercolatorProperty extends MappingPropertyBase {
+    type: 'percolator';
+}
+export interface MappingJoinProperty extends MappingPropertyBase {
+    relations?: Record<string, string | string[]>;
+    type: 'join';
+}
+export interface MappingFloatRangeProperty extends MappingRangePropertyBase {
+    type: 'float_range';
+}
+export declare type MappingMatchType = 'simple' | 'regex';
+export declare type MappingDynamicMapping = 'strict' | 'runtime' | 'true' | 'false';
+export interface MappingAllField {
+    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 IndicesAlias {
+    filter?: Record<string, any>;
+    index_routing?: string;
+    is_hidden?: boolean;
+    is_write_index?: boolean;
+    routing?: string;
+    search_routing?: string;
+}
+export interface IndicesIndexStatePrefixedSettings {
+    index: IndicesIndexSettings;
+}
+export interface TemplateBody extends IndexTemplateProperties {
+    version?: number;
+    order?: number;
+}
+export declare type MappingRuntimeFields = Record<string, MappingRuntimeField>;
+export interface MappingRoutingField {
+    required: boolean;
+}
+export interface MappingSourceField {
+    compress?: boolean;
+    compress_threshold?: string;
+    enabled: boolean;
+    excludes?: string[];
+    includes?: string[];
+}
+export interface MappingSizeField {
+    enabled: boolean;
+}
+export interface MappingIndexField {
+    enabled: boolean;
+}
+export interface MappingFieldNamesField {
+    enabled: boolean;
+}
+export interface IndicesResponseBase {
+    _shards?: ShardStatistics;
+    acknowledged: boolean;
+}
+export interface IndicesPutMappingTypeFieldMappings {
+    mappings: Partial<Record<string, MappingFieldMapping>>;
+}
+export interface IndicesPutSettingsIndexSettingsBody extends IndicesIndexSettings {
+    settings?: IndicesIndexSettings;
+}
+export declare type IndicesIndexCheckOnStartup = 'false' | 'checksum' | 'true';
+export interface IndicesIndexSettings {
+    number_of_shards?: number | string;
+    'index.number_of_shards'?: number | string;
+    number_of_replicas?: number | string;
+    'index.number_of_replicas'?: number | string;
+    number_of_routing_shards?: number;
+    'index.number_of_routing_shards'?: number;
+    check_on_startup?: IndicesIndexCheckOnStartup;
+    'index.check_on_startup'?: IndicesIndexCheckOnStartup;
+    codec?: string;
+    'index.codec'?: string;
+    routing_partition_size?: number | string;
+    'index.routing_partition_size'?: number | string;
+    'soft_deletes.retention_lease.period'?: number | string;
+    'index.soft_deletes.retention_lease.period'?: number | string;
+    load_fixed_bitset_filters_eagerly?: boolean;
+    'index.load_fixed_bitset_filters_eagerly'?: boolean;
+    hidden?: boolean | string;
+    'index.hidden'?: boolean | string;
+    auto_expand_replicas?: string;
+    'index.auto_expand_replicas'?: string;
+    'search.idle.after'?: number | string;
+    'index.search.idle.after'?: number | string;
+    refresh_interval?: number | string;
+    'index.refresh_interval'?: number | string;
+    max_result_window?: number;
+    'index.max_result_window'?: number;
+    max_inner_result_window?: number;
+    'index.max_inner_result_window'?: number;
+    max_rescore_window?: number;
+    'index.max_rescore_window'?: number;
+    max_docvalue_fields_search?: number;
+    'index.max_docvalue_fields_search'?: number;
+    max_script_fields?: number;
+    'index.max_script_fields'?: number;
+    max_ngram_diff?: number;
+    'index.max_ngram_diff'?: number;
+    max_shingle_diff?: number;
+    'index.max_shingle_diff'?: number;
+    blocks?: IndicesIndexSettingBlocks;
+    'index.blocks'?: IndicesIndexSettingBlocks;
+    max_refresh_listeners?: number;
+    'index.max_refresh_listeners'?: number;
+    'analyze.max_token_count'?: number;
+    'index.analyze.max_token_count'?: number;
+    'highlight.max_analyzed_offset'?: number;
+    'index.highlight.max_analyzed_offset'?: number;
+    max_terms_count?: number;
+    'index.max_terms_count'?: number;
+    max_regex_length?: number;
+    'index.max_regex_length'?: number;
+    routing?: IndicesIndexRouting;
+    'index.routing'?: IndicesIndexRouting;
+    gc_deletes?: number | string;
+    'index.gc_deletes'?: number | string;
+    default_pipeline?: string;
+    'index.default_pipeline'?: string;
+    final_pipeline?: string;
+    'index.final_pipeline'?: string;
+    lifecycle?: IndicesIndexSettingsLifecycle;
+    'index.lifecycle'?: IndicesIndexSettingsLifecycle;
+    provided_name?: string;
+    'index.provided_name'?: string;
+    creation_date?: string;
+    'index.creation_date'?: string;
+    uuid?: string;
+    'index.uuid'?: string;
+    version?: IndicesIndexVersioning;
+    'index.version'?: IndicesIndexVersioning;
+    verified_before_close?: boolean | string;
+    'index.verified_before_close'?: boolean | string;
+    format?: string | number;
+    'index.format'?: string | number;
+    max_slices_per_scroll?: number;
+    'index.max_slices_per_scroll'?: number;
+    'translog.durability'?: string;
+    'index.translog.durability'?: string;
+    'query_string.lenient'?: boolean | string;
+    'index.query_string.lenient'?: boolean | string;
+    priority?: number | string;
+    'index.priority'?: number | string;
+    top_metrics_max_size?: number;
+    analysis?: IndicesIndexSettingsAnalysis;
+}
+export interface IndicesIndexSettingsLifecycle {
+    name: string;
+}
+export interface IndicesIndexVersioning {
+    created: string;
+}
+export interface IndicesIndexSettingBlocks {
+    read_only?: boolean;
+    'index.blocks.read_only'?: boolean;
+    read_only_allow_delete?: boolean;
+    'index.blocks.read_only_allow_delete'?: boolean;
+    read?: boolean;
+    'index.blocks.read'?: boolean;
+    write?: boolean | string;
+    'index.blocks.write'?: boolean | string;
+    metadata?: boolean;
+    'index.blocks.metadata'?: boolean;
+}
+export interface IndicesIndexSettingsAnalysis {
+    char_filter?: Record<string, AnalysisCharFilter>;
+}
+export declare type AnalysisCharFilter = AnalysisHtmlStripCharFilter | AnalysisMappingCharFilter | AnalysisPatternReplaceTokenFilter;
+export declare type AnalysisHtmlStripCharFilter = AnalysisCharFilterBase;
+export interface AnalysisMappingCharFilter extends AnalysisCharFilterBase {
+    mappings: string[];
+    mappings_path: string;
+}
+export interface AnalysisPatternReplaceTokenFilter extends AnalysisTokenFilterBase {
+    flags: string;
+    pattern: string;
+    replacement: string;
+}
+export interface AnalysisTokenFilterBase {
+    type: string;
+    version?: string;
+}
+export interface AnalysisCharFilterBase {
+    type: string;
+    version?: string;
+}
+export interface DictionaryResponseBase<TValue = unknown> {
+    [key: string]: TValue;
+}
+export interface IndicesRecoveryRecoveryStatus {
+    shards: IndicesRecoveryShardRecovery[];
+}
+export interface IndicesRecoveryRecoveryBytes {
+    percent: string | number;
+    recovered?: string | number;
+    recovered_in_bytes: string | number;
+    reused?: string | number;
+    reused_in_bytes: string | number;
+    total?: string | number;
+    total_in_bytes: string | number;
+}
+export interface IndicesRecoveryRecoveryFiles {
+    details?: IndicesRecoveryFileDetails[];
+    percent: string | number;
+    recovered: number;
+    reused: number;
+    total: number;
+}
+export interface IndicesRecoveryFileDetails {
+    length: number;
+    name: string;
+    recovered: number;
+}
+export interface IndicesRecoveryRecoveryIndexStatus {
+    bytes?: IndicesRecoveryRecoveryBytes;
+    files: IndicesRecoveryRecoveryFiles;
+    size: IndicesRecoveryRecoveryBytes;
+    source_throttle_time?: string | number;
+    source_throttle_time_in_millis: string | number;
+    target_throttle_time?: string | number;
+    target_throttle_time_in_millis: string | number;
+    total_time_in_millis: string | number;
+    total_time?: string | number;
+}
+export interface IndicesRecoveryShardRecovery {
+    id: number;
+    index: IndicesRecoveryRecoveryIndexStatus;
+    primary: boolean;
+    source: IndicesRecoveryRecoveryOrigin;
+    stage: string;
+    start?: IndicesRecoveryRecoveryStartStatus;
+    start_time?: string;
+    start_time_in_millis: string | number;
+    stop_time?: string;
+    stop_time_in_millis: string | number;
+    target: IndicesRecoveryRecoveryOrigin;
+    total_time?: string;
+    total_time_in_millis: string | number;
+    translog: IndicesRecoveryTranslogStatus;
+    type: string;
+    verify_index: IndicesRecoveryVerifyIndex;
+}
+export interface IndicesRecoveryRecoveryOrigin {
+    hoststring?: string;
+    host?: string;
+    transport_address?: string;
+    id?: string;
+    ip?: string;
+    string?: string;
+    bootstrap_new_history_string?: boolean;
+    repository?: string;
+    snapshot?: string;
+    version?: string;
+    restorestring?: string;
+    index?: string;
+}
+export interface IndicesRecoveryVerifyIndex {
+    check_index_time?: string | number;
+    check_index_time_in_millis: string | number;
+    total_time?: string | number;
+    total_time_in_millis: string | number;
+}
+export interface IndicesRecoveryTranslogStatus {
+    percent: string | number;
+    recovered: number;
+    total: number;
+    total_on_start: number;
+    total_time?: string;
+    total_time_in_millis: string | number;
+}
+export interface IndicesRecoveryRecoveryStartStatus {
+    check_index_time: number;
+    total_time_in_millis: string;
+}
+export interface IndicesValidateQueryIndicesValidationExplanation {
+    error?: string;
+    explanation?: string;
+    index: string;
+    valid: boolean;
+}
+export interface MSearchHeader {
+    type?: string;
+    allow_no_indices?: boolean;
+    expand_wildcards?: ExpandWildcards;
+    ignore_unavailable?: boolean;
+    index?: string | string[];
+    preference?: string;
+    request_cache?: boolean;
+    routing?: string;
+    search_type?: SearchTypes;
+}
+export interface MSearchBody {
+    track_total_hits?: boolean | number;
+    query: Record<string, any>;
+    from?: number;
+    size?: number;
+}
+export interface IndividualResponse<T> extends SearchRecordResponse<T> {
+    status: number;
+}
+export interface SearchRecordResponse<T = Record<string, unknown>> {
+    took: number;
+    timed_out: boolean;
+    _scroll_id?: string;
+    terminated_early?: boolean;
+    max_score?: number;
+    fields?: Record<string, any>;
+    aggregations?: SearchAggregations;
+    _shards: {
+        total: number;
+        successful: number;
+        skipped: number;
+        failed: number;
+    };
+    hits: {
+        total: number | HitsTotal;
+        max_score: number;
+        hits: SearchResult<T>[];
+    };
+}
+export declare type SearchAggregations = Record<string, AggregationsAggregate>;
+export interface NodesInfoNodeInfoHttp {
+    bound_address: string[];
+    max_content_length?: number | string;
+    max_content_length_in_bytes: number;
+    publish_address: string;
+}
+export interface NodesInfoNodeInfoJvmMemory {
+    direct_max?: number | string;
+    direct_max_in_bytes: number;
+    heap_init?: number | string;
+    heap_init_in_bytes: number;
+    heap_max?: number | string;
+    heap_max_in_bytes: number;
+    non_heap_init?: number | string;
+    non_heap_init_in_bytes: number;
+    non_heap_max?: number | string;
+    non_heap_max_in_bytes: number;
+}
+export interface NodesInfoNodeJvmInfo {
+    gc_collectors: string[];
+    mem: NodesInfoNodeInfoJvmMemory;
+    memory_pools: string[];
+    pid: number;
+    start_time_in_millis: number;
+    version: string;
+    vm_name: string;
+    vm_vendor: string;
+    vm_version: string;
+    bundled_jdk: boolean;
+    using_bundled_jdk: boolean;
+    using_compressed_ordinary_object_pointers?: boolean | string;
+    input_arguments: string[];
+}
+export interface NodesInfoNodeInfoNetwork {
+    primary_interface: NodesInfoNodeInfoNetworkInterface;
+    refresh_interval: number;
+}
+export interface NodesInfoNodeInfoNetworkInterface {
+    address: string;
+    mac_address: string;
+    name: string;
+}
+export interface NodesInfoNodeOperatingSystemInfo {
+    arch: string;
+    available_processors: number;
+    allocated_processors?: number;
+    name: string;
+    pretty_name: string;
+    refresh_interval_in_millis: number;
+    version: string;
+    cpu?: NodesInfoNodeInfoOSCPU;
+    mem?: NodesInfoNodeInfoMemory;
+    swap?: NodesInfoNodeInfoMemory;
+}
+export interface NodesInfoNodeInfoMemory {
+    total: string;
+    total_in_bytes: number;
+}
+export interface NodesInfoNodeInfoOSCPU {
+    cache_size: string;
+    cache_size_in_bytes: number;
+    cores_per_socket: number;
+    mhz: number;
+    model: string;
+    total_cores: number;
+    total_sockets: number;
+    vendor: string;
+}
+export interface NodesInfoNodeProcessInfo {
+    id: number;
+    mlockall: boolean;
+    refresh_interval_in_millis: number;
+}
+export interface NodesInfoNodeThreadPoolInfo {
+    core?: number;
+    keep_alive?: string;
+    max?: number;
+    queue_size: number;
+    size?: number;
+    type: string;
+}
+export interface NodesInfoNodeInfo {
+    attributes: Record<string, string>;
+    build_hash: string;
+    build_type: string;
+    host: string;
+    http?: NodesInfoNodeInfoHttp;
+    ip: string;
+    jvm?: NodesInfoNodeJvmInfo;
+    name: string;
+    network?: NodesInfoNodeInfoNetwork;
+    os?: NodesInfoNodeOperatingSystemInfo;
+    plugins?: PluginStats[];
+    process?: NodesInfoNodeProcessInfo;
+    roles: NodeRoles;
+    settings?: NodesInfoNodeInfoSettings;
+    thread_pool?: Record<string, NodesInfoNodeThreadPoolInfo>;
+    total_indexing_buffer?: number;
+    total_indexing_buffer_in_bytes?: number | string;
+    transport?: NodesInfoNodeInfoTransport;
+    transport_address: string;
+    version: string;
+    modules?: PluginStats[];
+    ingest?: NodesInfoNodeInfoIngest;
+    aggregations?: Record<string, NodesInfoNodeInfoAggregation>;
+}
+export interface NodesInfoNodeInfoAggregation {
+    types: string[];
+}
+export interface NodesInfoNodeInfoIngest {
+    processors: NodesInfoNodeInfoIngestProcessor[];
+}
+export interface NodesInfoNodeInfoIngestProcessor {
+    type: string;
+}
+export interface NodesInfoNodeInfoSettingsCluster {
+    name: string;
+    routing?: IndicesIndexRouting;
+    election: NodesInfoNodeInfoSettingsClusterElection;
+    initial_cluster_manager_nodes?: string;
+    initial_master_nodes?: string;
+}
+export interface IndicesIndexRoutingAllocation {
+    enable?: IndicesIndexRoutingAllocationOptions;
+    include?: IndicesIndexRoutingAllocationInclude;
+    initial_recovery?: IndicesIndexRoutingAllocationInitialRecovery;
+    disk?: IndicesIndexRoutingAllocationDisk;
+}
+export interface IndicesIndexRoutingAllocationDisk {
+    threshold_enabled: boolean | string;
+}
+export interface IndicesIndexRoutingAllocationInclude {
+    _tier_preference?: string;
+    _id?: string;
+}
+export interface IndicesIndexRoutingAllocationInitialRecovery {
+    _id?: string;
+}
+export declare type IndicesIndexRoutingAllocationOptions = 'all' | 'primaries' | 'new_primaries' | 'none';
+export interface IndicesIndexRoutingRebalance {
+    enable: IndicesIndexRoutingRebalanceOptions;
+}
+export declare type IndicesIndexRoutingRebalanceOptions = 'all' | 'primaries' | 'replicas' | 'none';
+export interface IndicesIndexRouting {
+    allocation?: IndicesIndexRoutingAllocation;
+    rebalance?: IndicesIndexRoutingRebalance;
+}
+export interface NodesInfoNodeInfoSettingsClusterElection {
+    strategy: string;
+}
+export interface NodesInfoNodeInfoSettingsHttp {
+    type: string | NodesInfoNodeInfoSettingsHttpType;
+    'type.default'?: string;
+    compression?: boolean | string;
+    port?: number | string;
+}
+export interface NodesInfoNodeInfoSettingsHttpType {
+    default: string;
+}
+export interface NodesInfoNodeInfoSettingsNetwork {
+    host: string;
+}
+export interface NodesInfoNodeInfoSettingsNode {
+    name: string;
+    attr: Record<string, any>;
+    max_local_storage_nodes?: string;
+}
+export interface NodesInfoNodeInfoSettingsTransport {
+    type: string | NodesInfoNodeInfoSettingsTransportType;
+    'type.default'?: string;
+    features?: Record<string, any>;
+}
+export interface NodesInfoNodeInfoSettingsTransportType {
+    default: string;
+}
+export interface NodesInfoNodeInfoTransport {
+    bound_address: string[];
+    publish_address: string;
+    profiles: Record<string, string>;
+}
+export interface NodesInfoNodeInfoSettings {
+    cluster: NodesInfoNodeInfoSettingsCluster;
+    node: NodesInfoNodeInfoSettingsNode;
+    path: NodesInfoNodeInfoPath;
+    repositories?: NodesInfoNodeInfoRepositories;
+    discovery?: NodesInfoNodeInfoDiscover;
+    action?: NodesInfoNodeInfoAction;
+    client: NodesInfoNodeInfoClient;
+    http: NodesInfoNodeInfoSettingsHttp;
+    bootstrap?: NodesInfoNodeInfoBootstrap;
+    transport: NodesInfoNodeInfoSettingsTransport;
+    network?: NodesInfoNodeInfoSettingsNetwork;
+    script?: NodesInfoNodeInfoScript;
+    search?: NodesInfoNodeInfoSearch;
+}
+export interface NodesInfoNodeInfoSearch {
+    remote: NodesInfoNodeInfoSearchRemote;
+}
+export interface NodesInfoNodeInfoSearchRemote {
+    connect: string;
+}
+export interface NodesInfoNodeInfoScript {
+    allowed_types: string;
+    disable_max_compilations_rate: string;
+}
+export interface NodesInfoNodeInfoBootstrap {
+    memory_lock: string;
+}
+export interface NodesInfoNodeInfoDiscover {
+    seed_hosts: string;
+}
+export interface NodesInfoNodeInfoClient {
+    type: string;
+}
+export interface NodesInfoNodeInfoAction {
+    destructive_requires_name: string;
+}
+export interface NodesInfoNodeInfoPath {
+    logs: string;
+    home: string;
+    repo: string[];
+    data?: string[];
+}
+export interface NodesInfoNodeInfoRepositories {
+    url: NodesInfoNodeInfoRepositoriesUrl;
+}
+export interface NodesInfoNodeInfoRepositoriesUrl {
+    allowed_urls: string;
+}
+export declare type Level = 'cluster' | 'indices' | 'shards';
+export declare type Metrics = string | string[];
+export interface NodeStatistics {
+    failures?: ErrorCause[];
+    total: number;
+    successful: number;
+    failed: number;
+}
+export interface NodesStats {
+    adaptive_selection: Record<string, NodesAdaptiveSelection>;
+    breakers: Record<string, NodesBreaker>;
+    fs: NodesFileSystem;
+    host: string;
+    http: string;
+    indices: IndicesStatsIndexStats;
+    ingest: NodesIngest;
+    ip: string | string[];
+    jvm: NodesJvm;
+    name: string;
+    os: NodesOperatingSystem;
+    process: NodesProcess;
+    roles: NodeRoles;
+    script: NodesScripting;
+    thread_pool: Record<string, NodesThreadCount>;
+    timestamp: number;
+    transport: NodesTransport;
+    transport_address: string;
+    attributes: Record<string, string>;
+}
+export interface NodesTransport {
+    rx_count: number;
+    rx_size: string;
+    rx_size_in_bytes: number;
+    server_open: number;
+    tx_count: number;
+    tx_size: string;
+    tx_size_in_bytes: number;
+}
+export interface NodesThreadCount {
+    active: number;
+    completed: number;
+    largest: number;
+    queue: number;
+    rejected: number;
+    threads: number;
+}
+export interface IndicesStatsIndexStats {
+    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;
+    bulk?: BulkStats;
+}
+export interface StoreStats {
+    size?: number | string;
+    size_in_bytes: number;
+    reserved?: number | string;
+    reserved_in_bytes: number;
+    total_data_set_size?: number | string;
+    total_data_set_size_in_bytes?: number;
+}
+export interface BulkStats {
+    total_operations: number;
+    total_time?: string;
+    total_time_in_millis: number;
+    total_size?: number | string;
+    total_size_in_bytes: number;
+    avg_time?: string;
+    avg_time_in_millis: number;
+    avg_size?: number | string;
+    avg_size_in_bytes: number;
+}
+export interface WarmerStats {
+    current: number;
+    total: number;
+    total_time?: string;
+    total_time_in_millis: number;
+}
+export interface TranslogStats {
+    earliest_last_modified_age: number;
+    operations: number;
+    size?: string;
+    size_in_bytes: number;
+    uncommitted_operations: number;
+    uncommitted_size?: string;
+    uncommitted_size_in_bytes: number;
+}
+export interface SegmentsStats {
+    count: number;
+    doc_values_memory?: number | string;
+    doc_values_memory_in_bytes: number;
+    file_sizes: Record<string, IndicesStatsShardFileSizeInfo>;
+    fixed_bit_set?: number | string;
+    fixed_bit_set_memory_in_bytes: number;
+    index_writer_memory?: number | string;
+    index_writer_max_memory_in_bytes?: number;
+    index_writer_memory_in_bytes: number;
+    max_unsafe_auto_id_timestamp: number;
+    memory?: number | string;
+    memory_in_bytes: number;
+    norms_memory?: number | string;
+    norms_memory_in_bytes: number;
+    points_memory?: number | string;
+    points_memory_in_bytes: number;
+    stored_memory?: number | string;
+    stored_fields_memory_in_bytes: number;
+    terms_memory_in_bytes: number;
+    terms_memory?: number | string;
+    term_vectory_memory?: number | string;
+    term_vectors_memory_in_bytes: number;
+    version_map_memory?: number | string;
+    version_map_memory_in_bytes: number;
+}
+export interface IndicesStatsShardFileSizeInfo {
+    description: string;
+    size_in_bytes: number;
+    min_size_in_bytes?: number;
+    max_size_in_bytes?: number;
+    average_size_in_bytes?: number;
+    count?: number;
+}
+export interface SearchStats {
+    fetch_current: number;
+    fetch_time_in_millis: number;
+    fetch_total: number;
+    open_contexts?: number;
+    query_current: number;
+    query_time_in_millis: number;
+    query_total: number;
+    scroll_current: number;
+    scroll_time_in_millis: number;
+    scroll_total: number;
+    suggest_current: number;
+    suggest_time_in_millis: number;
+    suggest_total: number;
+    groups?: Record<string, SearchStats>;
+}
+export interface RequestCacheStats {
+    evictions: number;
+    hit_count: number;
+    memory_size?: string;
+    memory_size_in_bytes: number;
+    miss_count: number;
+}
+export interface RecoveryStats {
+    current_as_source: number;
+    current_as_target: number;
+    throttle_time?: string;
+    throttle_time_in_millis: number;
+}
+export interface RefreshStats {
+    external_total: number;
+    external_total_time_in_millis: number;
+    listeners: number;
+    total: number;
+    total_time?: string;
+    total_time_in_millis: number;
+}
+export interface QueryCacheStats {
+    cache_count: number;
+    cache_size: number;
+    evictions: number;
+    hit_count: number;
+    memory_size?: number | string;
+    memory_size_in_bytes: number;
+    miss_count: number;
+    total_count: number;
+}
+export interface MergesStats {
+    current: number;
+    current_docs: number;
+    current_size?: string;
+    current_size_in_bytes: number;
+    total: number;
+    total_auto_throttle?: string;
+    total_auto_throttle_in_bytes: number;
+    total_docs: number;
+    total_size?: string;
+    total_size_in_bytes: number;
+    total_stopped_time?: string;
+    total_stopped_time_in_millis: number;
+    total_throttled_time?: string;
+    total_throttled_time_in_millis: number;
+    total_time?: string;
+    total_time_in_millis: number;
+}
+export interface IndexingStats {
+    index_current: number;
+    delete_current: number;
+    delete_time?: string;
+    delete_time_in_millis: number;
+    delete_total: number;
+    is_throttled: boolean;
+    noop_update_total: number;
+    throttle_time?: string;
+    throttle_time_in_millis: number;
+    index_time?: string;
+    index_time_in_millis: number;
+    index_total: number;
+    index_failed: number;
+    types?: Record<string, IndexingStats>;
+}
+export interface GetStats {
+    current: number;
+    exists_time?: string;
+    exists_time_in_millis: number;
+    exists_total: number;
+    missing_time?: string;
+    missing_time_in_millis: number;
+    missing_total: number;
+    time?: string;
+    time_in_millis: number;
+    total: number;
+}
+export interface FlushStats {
+    periodic: number;
+    total: number;
+    total_time?: string;
+    total_time_in_millis: number;
+}
+export interface FielddataStats {
+    evictions?: number;
+    memory_size?: number | string;
+    memory_size_in_bytes: number;
+    fields?: Record<string, FieldMemoryUsage>;
+}
+export interface FieldMemoryUsage {
+    memory_size?: number | string;
+    memory_size_in_bytes: number;
+}
+export interface DocStats {
+    count: number;
+    deleted: number;
+}
+export interface CompletionStats {
+    size_in_bytes: number;
+    size?: number | string;
+    fields?: Record<string, FieldSizeUsage>;
+}
+export interface FieldSizeUsage {
+    size?: string | number;
+    size_in_bytes: number;
+}
+export interface NodesScripting {
+    cache_evictions: number;
+    compilations: number;
+}
+export interface NodesOperatingSystem {
+    cpu: NodesCpu;
+    mem: NodesExtendedMemoryStats;
+    swap: NodesMemoryStats;
+    timestamp: number;
+}
+export interface NodesExtendedMemoryStats extends NodesMemoryStats {
+    free_percent: number;
+    used_percent: number;
+    total_in_bytes: number;
+    free_in_bytes: number;
+    used_in_bytes: number;
+}
+export interface NodesNodeBufferPool {
+    count: number;
+    total_capacity: string;
+    total_capacity_in_bytes: number;
+    used: string;
+    used_in_bytes: number;
+}
+export interface NodesGarbageCollector {
+    collectors: Record<string, NodesGarbageCollectorTotal>;
+}
+export interface NodesGarbageCollectorTotal {
+    collection_count: number;
+    collection_time: string;
+    collection_time_in_millis: number;
+}
+export interface NodesJvm {
+    buffer_pools: Record<string, NodesNodeBufferPool>;
+    classes: NodesJvmClasses;
+    gc: NodesGarbageCollector;
+    mem: NodesMemoryStats;
+    threads: NodesJvmThreads;
+    timestamp: number;
+    uptime: string;
+    uptime_in_millis: number;
+}
+export interface NodesJvmClasses {
+    current_loaded_count: number;
+    total_loaded_count: number;
+    total_unloaded_count: number;
+}
+export interface NodesJvmThreads {
+    count: number;
+    peak_count: number;
+}
+export interface NodesProcess {
+    cpu: NodesCpu;
+    mem: NodesMemoryStats;
+    open_file_descriptors: number;
+    timestamp: number;
+}
+export interface NodesMemoryStats {
+    resident?: string;
+    resident_in_bytes?: number;
+    share?: string;
+    share_in_bytes?: number;
+    total_virtual?: string;
+    total_virtual_in_bytes?: number;
+    total_in_bytes: number;
+    free_in_bytes: number;
+    used_in_bytes: number;
+}
+export interface NodesCpu {
+    percent: number;
+    sys?: string;
+    sys_in_millis?: number;
+    total?: string;
+    total_in_millis?: number;
+    user?: string;
+    user_in_millis?: number;
+    load_average?: Record<string, number>;
+}
+export interface NodesIngest {
+    pipelines: Record<string, NodesIngestTotal>;
+    total: NodesIngestTotal;
+}
+export interface NodesKeyedProcessor {
+    statistics: NodesProcess;
+    type: string;
+}
+export interface NodesIngestTotal {
+    count: number;
+    current: number;
+    failed: number;
+    processors: NodesKeyedProcessor[];
+    time_in_millis: number;
+}
+export interface NodesDataPathStats {
+    available: string;
+    available_in_bytes: number;
+    disk_queue: string;
+    disk_reads: number;
+    disk_read_size: string;
+    disk_read_size_in_bytes: number;
+    disk_writes: number;
+    disk_write_size: string;
+    disk_write_size_in_bytes: number;
+    free: string;
+    free_in_bytes: number;
+    mount: string;
+    path: string;
+    total: string;
+    total_in_bytes: number;
+    type: string;
+}
+export interface NodesFileSystem {
+    data: NodesDataPathStats[];
+    timestamp: number;
+    total: NodesFileSystemTotal;
+}
+export interface NodesFileSystemTotal {
+    available: string;
+    available_in_bytes: number;
+    free: string;
+    free_in_bytes: number;
+    total: string;
+    total_in_bytes: number;
+}
+export interface NodesBreaker {
+    estimated_size: string;
+    estimated_size_in_bytes: number;
+    limit_size: string;
+    limit_size_in_bytes: number;
+    overhead: number;
+    tripped: number;
+}
+export interface NodesAdaptiveSelection {
+    avg_queue_size: number;
+    avg_response_time: number;
+    avg_response_time_ns: number;
+    avg_service_time: string;
+    avg_service_time_ns: number;
+    outgoing_searches: number;
+    rank: string;
+}
+export interface ReindexBody {
+    conflicts?: ConflictOptions;
+    max_docs?: number;
+    source: {
+        index: string;
+        query?: Record<string, any>;
+        remote?: Remote;
+        size?: number;
+        slice?: {
+            id?: number;
+            max?: number;
+        };
+        _source?: boolean | string | string[];
+    };
+    dest: {
+        index: string;
+        version_type?: VersionType;
+        op_type?: OpType;
+        type?: string;
+    };
+    script?: {
+        source?: string;
+        lang?: ScriptLangs;
+    };
+}
+export declare type AggregationsAggregate = AggregationsSingleBucketAggregate | AggregationsAutoDateHistogramAggregate | AggregationsFiltersAggregate | AggregationsSignificantTermsAggregate<any> | AggregationsTermsAggregate<any> | AggregationsBucketAggregate | AggregationsCompositeBucketAggregate | AggregationsMultiBucketAggregate<AggregationsBucket> | AggregationsMatrixStatsAggregate | AggregationsKeyedValueAggregate | AggregationsMetricAggregate;
+export interface AggregationsSingleBucketAggregateKeys extends AggregationsAggregateBase {
+    doc_count: number;
+}
+export interface AggregationsKeyedValueAggregate extends AggregationsValueAggregate {
+    keys: string[];
+}
+export declare type AggregationsValueBucket = {
+    [property: string]: AggregationsAggregate;
+};
+export declare type AggregationsBucket = AggregationsValueBucket | AggregationsKeyedBucket<any>;
+export interface AggregationsValueAggregate extends AggregationsAggregateBase {
+    value: number;
+    value_as_string?: string;
+}
+export interface AggregationsBoxPlotAggregate extends AggregationsAggregateBase {
+    min: number;
+    max: number;
+    q1: number;
+    q2: number;
+    q3: number;
+}
+export interface AggregationsGeoBoundsAggregate extends AggregationsAggregateBase {
+    bounds: AggregationsGeoBounds;
+}
+export interface LatLon {
+    lat: number;
+    lon: number;
+}
+export interface AggregationsGeoBounds {
+    bottom_right: LatLon;
+    top_left: LatLon;
+}
+export interface AggregationsGeoCentroidAggregate extends AggregationsAggregateBase {
+    count: number;
+    location: QueryDslGeoLocation;
+}
+export declare type QueryDslGeoLocation = string | number[] | LatLon;
+export interface AggregationsGeoLineAggregate extends AggregationsAggregateBase {
+    type: string;
+    geometry: AggregationsLineStringGeoShape;
+    properties: AggregationsGeoLineProperties;
+}
+export interface AggregationsLineStringGeoShape {
+    coordinates: QueryDslGeoCoordinate[];
+}
+export declare type QueryDslGeoCoordinate = string | number[] | QueryDslThreeDimensionalPoint;
+export interface QueryDslThreeDimensionalPoint {
+    lat: number;
+    lon: number;
+    z?: number;
+}
+export interface AggregationsGeoLineProperties {
+    complete: boolean;
+    sort_values: number[];
+}
+export declare type AggregationsMetricAggregate = AggregationsValueAggregate | AggregationsBoxPlotAggregate | AggregationsGeoBoundsAggregate | AggregationsGeoCentroidAggregate | AggregationsGeoLineAggregate | AggregationsPercentilesAggregate | AggregationsScriptedMetricAggregate | AggregationsStatsAggregate | AggregationsStringStatsAggregate | AggregationsTopHitsAggregate | AggregationsTopMetricsAggregate | AggregationsExtendedStatsAggregate | AggregationsTDigestPercentilesAggregate | AggregationsHdrPercentilesAggregate;
+export interface AggregationsTDigestPercentilesAggregate extends AggregationsAggregateBase {
+    values: Record<string, number>;
+}
+export interface AggregationsHdrPercentilesAggregate extends AggregationsAggregateBase {
+    values: AggregationsHdrPercentileItem[];
+}
+export interface AggregationsHdrPercentileItem {
+    key: number;
+    value: number;
+}
+export interface AggregationsStandardDeviationBounds {
+    lower?: number;
+    upper?: number;
+    lower_population?: number;
+    upper_population?: number;
+    lower_sampling?: number;
+    upper_sampling?: number;
+}
+export interface AggregationsExtendedStatsAggregate extends AggregationsStatsAggregate {
+    std_deviation_bounds: AggregationsStandardDeviationBounds;
+    sum_of_squares?: number;
+    variance?: number;
+    variance_population?: number;
+    variance_sampling?: number;
+    std_deviation?: number;
+    std_deviation_population?: number;
+    std_deviation_sampling?: number;
+}
+export interface AggregationsTopMetricsAggregate extends AggregationsAggregateBase {
+    top: AggregationsTopMetrics[];
+}
+export interface AggregationsTopMetrics {
+    sort: (number | number | string)[];
+    metrics: Record<string, number | number | string>;
+}
+export interface SearchHitsMetadata<T = unknown> {
+    total: SearchTotalHits | number;
+    hits: SearchResult<T>[];
+    max_score?: number;
+}
+export declare type SearchSortResults = (number | string | null)[];
+export interface SearchNestedIdentity {
+    field: string;
+    offset: number;
+    _nested?: SearchNestedIdentity;
+}
+export interface SearchInnerHitsMetadata {
+    total: SearchTotalHits | number;
+    hits: SearchResult<Record<string, any>>[];
+    max_score?: number;
+}
+export interface SearchInnerHitsResult {
+    hits: SearchInnerHitsMetadata;
+}
+export interface ExplainExplanation {
+    description: string;
+    details: ExplainExplanationDetail[];
+    value: number;
+}
+export interface ExplainExplanationDetail {
+    description: string;
+    details?: ExplainExplanationDetail[];
+    value: number;
+}
+export declare type SearchTotalHitsRelation = 'eq' | 'gte';
+export interface SearchTotalHits {
+    relation: SearchTotalHitsRelation;
+    value: number;
+}
+export interface AggregationsTopHitsAggregate extends AggregationsAggregateBase {
+    hits: SearchHitsMetadata<Record<string, any>>;
+}
+export interface AggregationsStringStatsAggregate extends AggregationsAggregateBase {
+    count: number;
+    min_length: number;
+    max_length: number;
+    avg_length: number;
+    entropy: number;
+    distribution?: Record<string, number>;
+}
+export interface AggregationsScriptedMetricAggregate extends AggregationsAggregateBase {
+    value: any;
+}
+export interface AggregationsStatsAggregate extends AggregationsAggregateBase {
+    count: number;
+    sum: number;
+    avg?: number;
+    max?: number;
+    min?: number;
+}
+export interface AggregationsPercentilesAggregate extends AggregationsAggregateBase {
+    items: AggregationsPercentileItem[];
+}
+export interface AggregationsPercentileItem {
+    percentile: number;
+    value: number;
+}
+export interface AggregationsMatrixStatsAggregate extends AggregationsAggregateBase {
+    correlation: Record<string, number>;
+    covariance: Record<string, number>;
+    count: number;
+    kurtosis: number;
+    mean: number;
+    skewness: number;
+    variance: number;
+    name: string;
+}
+export interface AggregationsCompositeBucketAggregate extends AggregationsMultiBucketAggregate<Record<string, any>> {
+    after_key: Record<string, any>;
+}
+export interface AggregationsFiltersAggregate extends AggregationsAggregateBase {
+    buckets: AggregationsFiltersBucketItem[] | Record<string, AggregationsFiltersBucketItem>;
+}
+export interface AggregationsBucketAggregate extends AggregationsAggregateBase {
+    after_key: Record<string, any>;
+    bg_count: number;
+    doc_count: number;
+    doc_count_error_upper_bound: number;
+    sum_other_doc_count: number;
+    interval: string;
+    items: AggregationsBucket;
+}
+export interface AggregationsTermsAggregate<TKey = unknown> extends AggregationsMultiBucketAggregate<TKey> {
+    doc_count_error_upper_bound: number;
+    sum_other_doc_count: number;
+}
+export interface AggregationsSignificantTermsAggregate<TKey = unknown> extends AggregationsMultiBucketAggregate<TKey> {
+    bg_count: number;
+    doc_count: number;
+}
+export interface AggregationsFiltersBucketItemKeys {
+    doc_count: number;
+}
+export declare type AggregationsFiltersBucketItem = AggregationsFiltersBucketItemKeys | {
+    [property: string]: AggregationsAggregate;
+};
+export interface AggregationsMultiBucketAggregate<TBucket = unknown> extends AggregationsAggregateBase {
+    buckets: TBucket[];
+}
+export interface AggregationsAggregateBase {
+    meta?: Record<string, any>;
+}
+export interface AggregationsKeyedBucketKeys<TKey = unknown> {
+    doc_count: number;
+    key: TKey;
+    key_as_string: string;
+}
+export interface AggregationsAutoDateHistogramAggregate extends AggregationsMultiBucketAggregate<AggregationsKeyedBucket<number>> {
+    interval: string;
+}
+export declare type AggregationsKeyedBucket<TKey = unknown> = AggregationsKeyedBucketKeys<TKey> | {
+    [property: string]: AggregationsAggregate;
+};
+export declare type AggregationsSingleBucketAggregate = AggregationsSingleBucketAggregateKeys | {
+    [property: string]: AggregationsAggregate;
+};
+export interface HitsTotal {
+    value: number;
+    relation: 'eq' | 'gte';
+}
+export interface IndicesStatsIndicesStats {
+    primaries: IndicesStatsIndexStats;
+    shards?: Record<string, IndicesStatsShardStats[]>;
+    total: IndicesStatsIndexStats;
+    uuid?: string;
+}
+export interface IndicesStatsShardStats {
+    commit: IndicesStatsShardCommit;
+    completion: CompletionStats;
+    docs: DocStats;
+    fielddata: FielddataStats;
+    flush: FlushStats;
+    get: GetStats;
+    indexing: IndexingStats;
+    merges: MergesStats;
+    shard_path: IndicesStatsShardPath;
+    query_cache: IndicesStatsShardQueryCache;
+    recovery: RecoveryStats;
+    refresh: RefreshStats;
+    request_cache: RequestCacheStats;
+    retention_leases: IndicesStatsShardRetentionLeases;
+    routing: IndicesStatsShardRouting;
+    search: SearchStats;
+    segments: SegmentsStats;
+    seq_no: IndicesStatsShardSequenceNumber;
+    store: StoreStats;
+    translog: TranslogStats;
+    warmer: WarmerStats;
+    bulk?: BulkStats;
+}
+export interface IndicesStatsShardSequenceNumber {
+    global_checkpoint: number;
+    local_checkpoint: number;
+    max_seq_no: number;
+}
+export interface IndicesStatsShardRouting {
+    node: string;
+    primary: boolean;
+    relocating_node?: string;
+    state: IndicesStatsShardRoutingState;
+}
+export declare type IndicesStatsShardRoutingState = 'UNASSIGNED' | 'INITIALIZING' | 'STARTED' | 'RELOCATING';
+export interface IndicesStatsShardRetentionLeases {
+    primary_term: number;
+    version: number;
+    leases: IndicesStatsShardLease[];
+}
+export interface IndicesStatsShardLease {
+    id: string;
+    retaining_seq_no: number;
+    timestamp: number;
+    source: string;
+}
+export interface IndicesStatsShardQueryCache {
+    cache_count: number;
+    cache_size: number;
+    evictions: number;
+    hit_count: number;
+    memory_size_in_bytes: number;
+    miss_count: number;
+    total_count: number;
+}
+export interface IndicesStatsShardPath {
+    data_path: string;
+    is_custom_data_path: boolean;
+    state_path: string;
+}
+export interface IndicesStatsShardCommit {
+    generation: number;
+    id: string;
+    num_docs: number;
+    user_data: Record<string, string>;
+}
+//# sourceMappingURL=elasticsearch-types.d.ts.map