@types/elasticsearch

  • Version 5.0.40
  • Published
  • 70.1 kB
  • No dependencies
  • MIT license

Install

npm i @types/elasticsearch
yarn add @types/elasticsearch
pnpm add @types/elasticsearch

Overview

TypeScript definitions for elasticsearch

Index

Classes

Interfaces

Type Aliases

Namespaces

Classes

class Client

class Client {}

    constructor

    constructor(params: ConfigOptions);

      property cat

      cat: Cat;

        property cluster

        cluster: Cluster;

          property indices

          indices: Indices;

            property ingest

            ingest: Ingest;

              property nodes

              nodes: Nodes;

                property snapshot

                snapshot: Snapshot;

                  property tasks

                  tasks: Tasks;

                    method bulk

                    bulk: {
                    (
                    params: BulkIndexDocumentsParams,
                    callback: (error: any, response: any) => void
                    ): void;
                    (params: BulkIndexDocumentsParams): Promise<any>;
                    };

                      method clearScroll

                      clearScroll: {
                      (
                      params: ClearScrollParams,
                      callback: (error: any, response: any) => void
                      ): void;
                      (params: ClearScrollParams): Promise<any>;
                      };

                        method close

                        close: () => void;

                          method count

                          count: {
                          (
                          params: CountParams,
                          callback: (error: any, response: CountResponse) => void
                          ): void;
                          (params: CountParams): Promise<CountResponse>;
                          };

                            method create

                            create: {
                            (
                            params: CreateDocumentParams,
                            callback: (
                            err: any,
                            response: CreateDocumentResponse,
                            status: any
                            ) => void
                            ): void;
                            (params: CreateDocumentParams): Promise<CreateDocumentResponse>;
                            };

                              method delete

                              delete: {
                              (
                              params: DeleteDocumentParams,
                              callback: (error: any, response: DeleteDocumentResponse) => void
                              ): void;
                              (params: DeleteDocumentParams): Promise<DeleteDocumentResponse>;
                              };

                                method deleteByQuery

                                deleteByQuery: {
                                (
                                params: DeleteDocumentByQueryParams,
                                callback: (error: any, response: DeleteDocumentByQueryResponse) => void
                                ): void;
                                (
                                params: DeleteDocumentByQueryParams
                                ): Promise<DeleteDocumentByQueryResponse>;
                                };

                                  method deleteScript

                                  deleteScript: {
                                  (
                                  params: DeleteScriptParams,
                                  callback: (error: any, response: any) => void
                                  ): void;
                                  (params: DeleteScriptParams): Promise<any>;
                                  };

                                    method deleteTemplate

                                    deleteTemplate: {
                                    (
                                    params: DeleteTemplateParams,
                                    callback: (error: any, response: any) => void
                                    ): void;
                                    (params: DeleteTemplateParams): Promise<any>;
                                    };

                                      method exists

                                      exists: {
                                      (
                                      params: ExistsParams,
                                      callback: (error: any, response: boolean, status?: any) => void
                                      ): void;
                                      (params: ExistsParams): Promise<boolean>;
                                      };

                                        method explain

                                        explain: {
                                        (
                                        params: ExplainParams,
                                        callback: (error: any, response: ExplainResponse) => void
                                        ): void;
                                        (params: ExplainParams): Promise<ExplainResponse>;
                                        };

                                          method fieldStats

                                          fieldStats: {
                                          (
                                          params: FieldStatsParams,
                                          callback: (error: any, response: FieldStatsResponse) => void
                                          ): void;
                                          (params: FieldStatsParams): Promise<FieldStatsResponse>;
                                          };

                                            method get

                                            get: {
                                            <T>(
                                            params: GetParams,
                                            callback: (error: any, response: GetResponse<T>) => void
                                            ): void;
                                            <T>(params: GetParams): Promise<GetResponse<T>>;
                                            };

                                              method getScript

                                              getScript: {
                                              (
                                              params: GetScriptParams,
                                              callback: (error: any, response: any) => void
                                              ): void;
                                              (params: GetScriptParams): Promise<any>;
                                              };

                                                method getSource

                                                getSource: {
                                                (
                                                params: GetSourceParams,
                                                callback: (error: any, response: any) => void
                                                ): void;
                                                (params: GetSourceParams): Promise<any>;
                                                };

                                                  method getTemplate

                                                  getTemplate: {
                                                  (
                                                  params: GetTemplateParams,
                                                  callback: (error: any, response: any) => void
                                                  ): void;
                                                  (params: GetTemplateParams): Promise<any>;
                                                  };

                                                    method index

                                                    index: {
                                                    <T>(
                                                    params: IndexDocumentParams<T>,
                                                    callback: (error: any, response: any) => void
                                                    ): void;
                                                    <T>(params: IndexDocumentParams<T>): Promise<any>;
                                                    };

                                                      method info

                                                      info: {
                                                      (params: InfoParams, callback: (error: any, response: any) => void): void;
                                                      (params: InfoParams): Promise<any>;
                                                      };

                                                        method mget

                                                        mget: {
                                                        <T>(
                                                        params: MGetParams,
                                                        callback: (error: any, response: MGetResponse<T>) => void
                                                        ): void;
                                                        <T>(params: MGetParams): Promise<MGetResponse<T>>;
                                                        };

                                                          method msearch

                                                          msearch: {
                                                          <T>(
                                                          params: MSearchParams,
                                                          callback: (error: any, response: MSearchResponse<T>) => void
                                                          ): void;
                                                          <T>(params: MSearchParams): Promise<MSearchResponse<T>>;
                                                          };

                                                            method msearchTemplate

                                                            msearchTemplate: {
                                                            <T>(
                                                            params: MSearchTemplateParams,
                                                            callback: (error: any, response: MSearchResponse<T>) => void
                                                            ): void;
                                                            <T>(params: MSearchTemplateParams): Promise<MSearchResponse<T>>;
                                                            };

                                                              method mtermvectors

                                                              mtermvectors: {
                                                              (
                                                              params: MTermVectorsParams,
                                                              callback: (error: any, response: any) => void
                                                              ): void;
                                                              (params: MTermVectorsParams): Promise<any>;
                                                              };

                                                                method ping

                                                                ping: {
                                                                (
                                                                params: PingParams,
                                                                callback: (err: any, response: any, status: any) => void
                                                                ): void;
                                                                (params: PingParams): Promise<any>;
                                                                };

                                                                  method putScript

                                                                  putScript: {
                                                                  (
                                                                  params: PutScriptParams,
                                                                  callback: (err: any, response: any, status: any) => void
                                                                  ): void;
                                                                  (params: PutScriptParams): Promise<any>;
                                                                  };

                                                                    method putTemplate

                                                                    putTemplate: {
                                                                    (
                                                                    params: PutTemplateParams,
                                                                    callback: (err: any, response: any, status: any) => void
                                                                    ): void;
                                                                    (params: PutTemplateParams): Promise<any>;
                                                                    };

                                                                      method reindex

                                                                      reindex: {
                                                                      (
                                                                      params: ReindexParams,
                                                                      callback: (error: any, response: ReindexResponse) => void
                                                                      ): void;
                                                                      (params: ReindexParams): Promise<ReindexResponse>;
                                                                      };

                                                                        method reindexRethrottle

                                                                        reindexRethrottle: {
                                                                        (
                                                                        params: ReindexRethrottleParams,
                                                                        callback: (error: any, response: any) => void
                                                                        ): void;
                                                                        (params: ReindexRethrottleParams): Promise<any>;
                                                                        };

                                                                          method renderSearchTemplate

                                                                          renderSearchTemplate: {
                                                                          (
                                                                          params: RenderSearchTemplateParams,
                                                                          callback: (error: any, response: any) => void
                                                                          ): void;
                                                                          (params: RenderSearchTemplateParams): Promise<any>;
                                                                          };

                                                                            method scroll

                                                                            scroll: {
                                                                            <T>(
                                                                            params: ScrollParams,
                                                                            callback: (error: any, response: SearchResponse<T>) => void
                                                                            ): void;
                                                                            <T>(params: ScrollParams): Promise<SearchResponse<T>>;
                                                                            };

                                                                              method search

                                                                              search: {
                                                                              <T>(
                                                                              params: SearchParams,
                                                                              callback: (error: any, response: SearchResponse<T>) => void
                                                                              ): void;
                                                                              <T>(params: SearchParams): Promise<SearchResponse<T>>;
                                                                              };

                                                                                method searchShards

                                                                                searchShards: {
                                                                                (
                                                                                params: SearchShardsParams,
                                                                                callback: (error: any, response: SearchShardsResponse) => void
                                                                                ): void;
                                                                                (params: SearchShardsParams): Promise<SearchShardsResponse>;
                                                                                };

                                                                                  method searchTemplate

                                                                                  searchTemplate: {
                                                                                  (
                                                                                  params: SearchTemplateParams,
                                                                                  callback: (error: any, response: any) => void
                                                                                  ): void;
                                                                                  (params: SearchTemplateParams): Promise<any>;
                                                                                  };

                                                                                    method suggest

                                                                                    suggest: {
                                                                                    (params: SuggestParams, callback: (error: any, response: any) => void): void;
                                                                                    (params: SuggestParams): Promise<any>;
                                                                                    };

                                                                                      method termvectors

                                                                                      termvectors: {
                                                                                      (
                                                                                      params: TermvectorsParams,
                                                                                      callback: (error: any, response: any) => void
                                                                                      ): void;
                                                                                      (params: TermvectorsParams): Promise<any>;
                                                                                      };

                                                                                        method update

                                                                                        update: {
                                                                                        (
                                                                                        params: UpdateDocumentParams,
                                                                                        callback: (error: any, response: any) => void
                                                                                        ): void;
                                                                                        (params: UpdateDocumentParams): Promise<any>;
                                                                                        };

                                                                                          method updateByQuery

                                                                                          updateByQuery: {
                                                                                          (
                                                                                          params: UpdateDocumentByQueryParams,
                                                                                          callback: (error: any, response: UpdateDocumentByQueryResponse) => void
                                                                                          ): void;
                                                                                          (
                                                                                          params: UpdateDocumentByQueryParams
                                                                                          ): Promise<UpdateDocumentByQueryResponse>;
                                                                                          };

                                                                                            class Indices

                                                                                            class Indices {}

                                                                                              method analyze

                                                                                              analyze: {
                                                                                              (
                                                                                              params: IndicesAnalyzeParams,
                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                              ): void;
                                                                                              (params: IndicesAnalyzeParams): Promise<any>;
                                                                                              };

                                                                                                method clearCache

                                                                                                clearCache: {
                                                                                                (
                                                                                                params: IndicesClearCacheParams,
                                                                                                callback: (error: any, response: any, status: any) => void
                                                                                                ): void;
                                                                                                (params: IndicesClearCacheParams): Promise<any>;
                                                                                                };

                                                                                                  method close

                                                                                                  close: {
                                                                                                  (
                                                                                                  params: IndicesCloseParams,
                                                                                                  callback: (error: any, response: any, status: any) => void
                                                                                                  ): void;
                                                                                                  (params: IndicesCloseParams): Promise<any>;
                                                                                                  };

                                                                                                    method create

                                                                                                    create: {
                                                                                                    (
                                                                                                    params: IndicesCreateParams,
                                                                                                    callback: (error: any, response: any, status: any) => void
                                                                                                    ): void;
                                                                                                    (params: IndicesCreateParams): Promise<any>;
                                                                                                    };

                                                                                                      method delete

                                                                                                      delete: {
                                                                                                      (
                                                                                                      params: IndicesDeleteParams,
                                                                                                      callback: (error: any, response: any, status: any) => void
                                                                                                      ): void;
                                                                                                      (params: IndicesDeleteParams): Promise<any>;
                                                                                                      };

                                                                                                        method deleteAlias

                                                                                                        deleteAlias: {
                                                                                                        (
                                                                                                        params: IndicesDeleteAliasParams,
                                                                                                        callback: (error: any, response: any, status: any) => void
                                                                                                        ): void;
                                                                                                        (params: IndicesDeleteAliasParams): Promise<any>;
                                                                                                        };

                                                                                                          method deleteTemplate

                                                                                                          deleteTemplate: {
                                                                                                          (
                                                                                                          params: IndicesDeleteTemplateParams,
                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                          ): void;
                                                                                                          (params: IndicesDeleteTemplateParams): Promise<any>;
                                                                                                          };

                                                                                                            method exists

                                                                                                            exists: {
                                                                                                            (
                                                                                                            params: IndicesExistsParams,
                                                                                                            callback: (error: any, response: boolean, status: any) => void
                                                                                                            ): void;
                                                                                                            (params: IndicesExistsParams): Promise<boolean>;
                                                                                                            };

                                                                                                              method existsAlias

                                                                                                              existsAlias: {
                                                                                                              (
                                                                                                              params: IndicesExistsAliasParams,
                                                                                                              callback: (error: any, response: boolean, status: any) => void
                                                                                                              ): void;
                                                                                                              (params: IndicesExistsAliasParams): Promise<boolean>;
                                                                                                              };

                                                                                                                method existsTemplate

                                                                                                                existsTemplate: {
                                                                                                                (
                                                                                                                params: IndicesExistsTemplateParams,
                                                                                                                callback: (error: any, response: boolean, status: any) => void
                                                                                                                ): void;
                                                                                                                (params: IndicesExistsTemplateParams): Promise<boolean>;
                                                                                                                };

                                                                                                                  method existsType

                                                                                                                  existsType: {
                                                                                                                  (
                                                                                                                  params: IndicesExistsTypeParams,
                                                                                                                  callback: (error: any, response: boolean, status: any) => void
                                                                                                                  ): void;
                                                                                                                  (params: IndicesExistsTypeParams): Promise<boolean>;
                                                                                                                  };

                                                                                                                    method flush

                                                                                                                    flush: {
                                                                                                                    (
                                                                                                                    params: IndicesFlushParams,
                                                                                                                    callback: (error: any, response: any, status: any) => void
                                                                                                                    ): void;
                                                                                                                    (params: IndicesFlushParams): Promise<any>;
                                                                                                                    };

                                                                                                                      method flushSynced

                                                                                                                      flushSynced: {
                                                                                                                      (
                                                                                                                      params: IndicesFlushSyncedParams,
                                                                                                                      callback: (error: any, response: any, status: any) => void
                                                                                                                      ): void;
                                                                                                                      (params: IndicesFlushSyncedParams): Promise<any>;
                                                                                                                      };

                                                                                                                        method forcemerge

                                                                                                                        forcemerge: {
                                                                                                                        (
                                                                                                                        params: IndicesForcemergeParams,
                                                                                                                        callback: (error: any, response: any, status: any) => void
                                                                                                                        ): void;
                                                                                                                        (params: IndicesForcemergeParams): Promise<any>;
                                                                                                                        };

                                                                                                                          method get

                                                                                                                          get: {
                                                                                                                          (
                                                                                                                          params: IndicesGetParams,
                                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                                          ): void;
                                                                                                                          (params: IndicesGetParams): Promise<any>;
                                                                                                                          };

                                                                                                                            method getAlias

                                                                                                                            getAlias: {
                                                                                                                            (
                                                                                                                            params: IndicesGetAliasParams,
                                                                                                                            callback: (error: any, response: any, status: any) => void
                                                                                                                            ): void;
                                                                                                                            (params: IndicesGetAliasParams): Promise<any>;
                                                                                                                            };

                                                                                                                              method getFieldMapping

                                                                                                                              getFieldMapping: {
                                                                                                                              (
                                                                                                                              params: IndicesGetFieldMappingParams,
                                                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                                                              ): void;
                                                                                                                              (params: IndicesGetFieldMappingParams): Promise<any>;
                                                                                                                              };

                                                                                                                                method getMapping

                                                                                                                                getMapping: {
                                                                                                                                (
                                                                                                                                params: IndicesGetMappingParams,
                                                                                                                                callback: (error: any, response: any, status: any) => void
                                                                                                                                ): void;
                                                                                                                                (params: IndicesGetMappingParams): Promise<any>;
                                                                                                                                };

                                                                                                                                  method getSettings

                                                                                                                                  getSettings: {
                                                                                                                                  (
                                                                                                                                  params: IndicesGetSettingsParams,
                                                                                                                                  callback: (error: any, response: any, status: any) => void
                                                                                                                                  ): void;
                                                                                                                                  (params: IndicesGetSettingsParams): Promise<any>;
                                                                                                                                  };

                                                                                                                                    method getTemplate

                                                                                                                                    getTemplate: {
                                                                                                                                    (
                                                                                                                                    params: IndicesGetTemplateParams,
                                                                                                                                    callback: (error: any, response: any, status: any) => void
                                                                                                                                    ): void;
                                                                                                                                    (params: IndicesGetTemplateParams): Promise<any>;
                                                                                                                                    };

                                                                                                                                      method getUpgrade

                                                                                                                                      getUpgrade: {
                                                                                                                                      (
                                                                                                                                      params: IndicesGetUpgradeParams,
                                                                                                                                      callback: (error: any, response: any, status: any) => void
                                                                                                                                      ): void;
                                                                                                                                      (params: IndicesGetUpgradeParams): Promise<any>;
                                                                                                                                      };

                                                                                                                                        method open

                                                                                                                                        open: {
                                                                                                                                        (
                                                                                                                                        params: IndicesOpenParams,
                                                                                                                                        callback: (error: any, response: any, status: any) => void
                                                                                                                                        ): void;
                                                                                                                                        (params: IndicesOpenParams): Promise<any>;
                                                                                                                                        };

                                                                                                                                          method putAlias

                                                                                                                                          putAlias: {
                                                                                                                                          (
                                                                                                                                          params: IndicesPutAliasParams,
                                                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                                                          ): void;
                                                                                                                                          (params: IndicesPutAliasParams): Promise<any>;
                                                                                                                                          };

                                                                                                                                            method putMapping

                                                                                                                                            putMapping: {
                                                                                                                                            (
                                                                                                                                            params: IndicesPutMappingParams,
                                                                                                                                            callback: (error: any, response: any, status: any) => void
                                                                                                                                            ): void;
                                                                                                                                            (params: IndicesPutMappingParams): Promise<any>;
                                                                                                                                            };

                                                                                                                                              method putSettings

                                                                                                                                              putSettings: {
                                                                                                                                              (
                                                                                                                                              params: IndicesPutSettingsParams,
                                                                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                                                                              ): void;
                                                                                                                                              (params: IndicesPutSettingsParams): Promise<any>;
                                                                                                                                              };

                                                                                                                                                method putTemplate

                                                                                                                                                putTemplate: {
                                                                                                                                                (
                                                                                                                                                params: IndicesPutTemplateParams,
                                                                                                                                                callback: (error: any, response: any) => void
                                                                                                                                                ): void;
                                                                                                                                                (params: IndicesPutTemplateParams): Promise<any>;
                                                                                                                                                };

                                                                                                                                                  method recovery

                                                                                                                                                  recovery: {
                                                                                                                                                  (
                                                                                                                                                  params: IndicesRecoveryParams,
                                                                                                                                                  callback: (error: any, response: any) => void
                                                                                                                                                  ): void;
                                                                                                                                                  (params: IndicesRecoveryParams): Promise<any>;
                                                                                                                                                  };

                                                                                                                                                    method refresh

                                                                                                                                                    refresh: {
                                                                                                                                                    (
                                                                                                                                                    params: IndicesRefreshParams,
                                                                                                                                                    callback: (error: any, response: any) => void
                                                                                                                                                    ): void;
                                                                                                                                                    (params: IndicesRefreshParams): Promise<any>;
                                                                                                                                                    };

                                                                                                                                                      method rollover

                                                                                                                                                      rollover: {
                                                                                                                                                      (
                                                                                                                                                      params: IndicesRolloverParams,
                                                                                                                                                      callback: (error: any, response: IndicesRolloverResponse) => void
                                                                                                                                                      ): void;
                                                                                                                                                      (params: IndicesRolloverParams): Promise<IndicesRolloverResponse>;
                                                                                                                                                      };

                                                                                                                                                        method segments

                                                                                                                                                        segments: {
                                                                                                                                                        (
                                                                                                                                                        params: IndicesSegmentsParams,
                                                                                                                                                        callback: (error: any, response: any) => void
                                                                                                                                                        ): void;
                                                                                                                                                        (params: IndicesSegmentsParams): Promise<any>;
                                                                                                                                                        };

                                                                                                                                                          method shardStores

                                                                                                                                                          shardStores: {
                                                                                                                                                          (
                                                                                                                                                          params: IndicesShardStoresParams,
                                                                                                                                                          callback: (error: any, response: any) => void
                                                                                                                                                          ): void;
                                                                                                                                                          (params: IndicesShardStoresParams): Promise<any>;
                                                                                                                                                          };

                                                                                                                                                            method shrink

                                                                                                                                                            shrink: {
                                                                                                                                                            (
                                                                                                                                                            params: IndicesShrinkParams,
                                                                                                                                                            callback: (error: any, response: any) => void
                                                                                                                                                            ): void;
                                                                                                                                                            (params: IndicesShrinkParams): Promise<any>;
                                                                                                                                                            };

                                                                                                                                                              method stats

                                                                                                                                                              stats: {
                                                                                                                                                              (
                                                                                                                                                              params: IndicesStatsParams,
                                                                                                                                                              callback: (error: any, response: any) => void
                                                                                                                                                              ): void;
                                                                                                                                                              (params: IndicesStatsParams): Promise<any>;
                                                                                                                                                              };

                                                                                                                                                                method updateAliases

                                                                                                                                                                updateAliases: {
                                                                                                                                                                (
                                                                                                                                                                params: IndicesUpdateAliasesParams,
                                                                                                                                                                callback: (error: any, response: any) => void
                                                                                                                                                                ): void;
                                                                                                                                                                (params: IndicesUpdateAliasesParams): Promise<any>;
                                                                                                                                                                };

                                                                                                                                                                  method upgrade

                                                                                                                                                                  upgrade: {
                                                                                                                                                                  (
                                                                                                                                                                  params: IndicesUpgradeParams,
                                                                                                                                                                  callback: (error: any, response: any) => void
                                                                                                                                                                  ): void;
                                                                                                                                                                  (params: IndicesUpgradeParams): Promise<any>;
                                                                                                                                                                  };

                                                                                                                                                                    method validateQuery

                                                                                                                                                                    validateQuery: {
                                                                                                                                                                    (
                                                                                                                                                                    params: IndicesValidateQueryParams,
                                                                                                                                                                    callback: (error: any, response: any) => void
                                                                                                                                                                    ): void;
                                                                                                                                                                    (params: IndicesValidateQueryParams): Promise<any>;
                                                                                                                                                                    };

                                                                                                                                                                      class Ingest

                                                                                                                                                                      class Ingest {}

                                                                                                                                                                        method deletePipeline

                                                                                                                                                                        deletePipeline: {
                                                                                                                                                                        (
                                                                                                                                                                        params: IngestDeletePipelineParams,
                                                                                                                                                                        callback: (error: any, response: any, status: any) => void
                                                                                                                                                                        ): void;
                                                                                                                                                                        (params: IngestDeletePipelineParams): Promise<any>;
                                                                                                                                                                        };

                                                                                                                                                                          method getPipeline

                                                                                                                                                                          getPipeline: {
                                                                                                                                                                          (
                                                                                                                                                                          params: IngestGetPipelineParams,
                                                                                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                                                                                          ): void;
                                                                                                                                                                          (params: IngestGetPipelineParams): Promise<any>;
                                                                                                                                                                          };

                                                                                                                                                                            method putPipeline

                                                                                                                                                                            putPipeline: {
                                                                                                                                                                            (
                                                                                                                                                                            params: IngestPutPipelineParams,
                                                                                                                                                                            callback: (error: any, response: any, status: any) => void
                                                                                                                                                                            ): void;
                                                                                                                                                                            (params: IngestPutPipelineParams): Promise<any>;
                                                                                                                                                                            };

                                                                                                                                                                              method simulate

                                                                                                                                                                              simulate: {
                                                                                                                                                                              (
                                                                                                                                                                              params: IngestSimulateParams,
                                                                                                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                                                                                                              ): void;
                                                                                                                                                                              (params: IngestSimulateParams): Promise<any>;
                                                                                                                                                                              };

                                                                                                                                                                                class Nodes

                                                                                                                                                                                class Nodes {}

                                                                                                                                                                                  method hotThreads

                                                                                                                                                                                  hotThreads: {
                                                                                                                                                                                  (
                                                                                                                                                                                  params: NodesHotThreadsParams,
                                                                                                                                                                                  callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                  ): void;
                                                                                                                                                                                  (params: NodesHotThreadsParams): Promise<any>;
                                                                                                                                                                                  };

                                                                                                                                                                                    method info

                                                                                                                                                                                    info: {
                                                                                                                                                                                    (
                                                                                                                                                                                    params: NodesInfoParams,
                                                                                                                                                                                    callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                    ): void;
                                                                                                                                                                                    (params: NodesInfoParams): Promise<any>;
                                                                                                                                                                                    };

                                                                                                                                                                                      method stats

                                                                                                                                                                                      stats: {
                                                                                                                                                                                      (
                                                                                                                                                                                      params: NodesStatsParams,
                                                                                                                                                                                      callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                      ): void;
                                                                                                                                                                                      (params: NodesStatsParams): Promise<any>;
                                                                                                                                                                                      };

                                                                                                                                                                                        class Snapshot

                                                                                                                                                                                        class Snapshot {}

                                                                                                                                                                                          method create

                                                                                                                                                                                          create: {
                                                                                                                                                                                          (
                                                                                                                                                                                          params: SnapshotCreateParams,
                                                                                                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                          ): void;
                                                                                                                                                                                          (params: SnapshotCreateParams): Promise<any>;
                                                                                                                                                                                          };

                                                                                                                                                                                            method createRepository

                                                                                                                                                                                            createRepository: {
                                                                                                                                                                                            (
                                                                                                                                                                                            params: SnapshotCreateRepositoryParams,
                                                                                                                                                                                            callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                            ): void;
                                                                                                                                                                                            (params: SnapshotCreateRepositoryParams): Promise<any>;
                                                                                                                                                                                            };

                                                                                                                                                                                              method delete

                                                                                                                                                                                              delete: {
                                                                                                                                                                                              (
                                                                                                                                                                                              params: SnapshotDeleteParams,
                                                                                                                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                              ): void;
                                                                                                                                                                                              (params: SnapshotDeleteParams): Promise<any>;
                                                                                                                                                                                              };

                                                                                                                                                                                                method deleteRepository

                                                                                                                                                                                                deleteRepository: {
                                                                                                                                                                                                (
                                                                                                                                                                                                params: SnapshotDeleteRepositoryParams,
                                                                                                                                                                                                callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                ): void;
                                                                                                                                                                                                (params: SnapshotDeleteRepositoryParams): Promise<any>;
                                                                                                                                                                                                };

                                                                                                                                                                                                  method get

                                                                                                                                                                                                  get: {
                                                                                                                                                                                                  (
                                                                                                                                                                                                  params: SnapshotGetParams,
                                                                                                                                                                                                  callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                  (params: SnapshotGetParams): Promise<any>;
                                                                                                                                                                                                  };

                                                                                                                                                                                                    method getRepository

                                                                                                                                                                                                    getRepository: {
                                                                                                                                                                                                    (
                                                                                                                                                                                                    params: SnapshotGetRepositoryParams,
                                                                                                                                                                                                    callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                    (params: SnapshotGetRepositoryParams): Promise<any>;
                                                                                                                                                                                                    };

                                                                                                                                                                                                      method restore

                                                                                                                                                                                                      restore: {
                                                                                                                                                                                                      (
                                                                                                                                                                                                      params: SnapshotRestoreParams,
                                                                                                                                                                                                      callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                      (params: SnapshotRestoreParams): Promise<any>;
                                                                                                                                                                                                      };

                                                                                                                                                                                                        method status

                                                                                                                                                                                                        status: {
                                                                                                                                                                                                        (
                                                                                                                                                                                                        params: SnapshotStatusParams,
                                                                                                                                                                                                        callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                        (params: SnapshotStatusParams): Promise<any>;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          method verifyRepository

                                                                                                                                                                                                          verifyRepository: {
                                                                                                                                                                                                          (
                                                                                                                                                                                                          params: SnapshotVerifyRepositoryParams,
                                                                                                                                                                                                          callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                          (params: SnapshotVerifyRepositoryParams): Promise<any>;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            class Tasks

                                                                                                                                                                                                            class Tasks {}

                                                                                                                                                                                                              method cancel

                                                                                                                                                                                                              cancel: {
                                                                                                                                                                                                              (
                                                                                                                                                                                                              params: TasksCancelParams,
                                                                                                                                                                                                              callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                              (params: TasksCancelParams): Promise<any>;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method get

                                                                                                                                                                                                                get: {
                                                                                                                                                                                                                (
                                                                                                                                                                                                                params: TasksGetParams,
                                                                                                                                                                                                                callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                (params: TasksGetParams): Promise<any>;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method list

                                                                                                                                                                                                                  list: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  params: TasksListParams,
                                                                                                                                                                                                                  callback: (error: any, response: any, status: any) => void
                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                  (params: TasksListParams): Promise<any>;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                    interface BulkIndexDocumentsParams

                                                                                                                                                                                                                    interface BulkIndexDocumentsParams extends GenericParams {}

                                                                                                                                                                                                                      property fields

                                                                                                                                                                                                                      fields?: NameList | undefined;

                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                        index?: string | undefined;

                                                                                                                                                                                                                          property pipeline

                                                                                                                                                                                                                          pipeline?: string | undefined;

                                                                                                                                                                                                                            property refresh

                                                                                                                                                                                                                            refresh?: Refresh | undefined;

                                                                                                                                                                                                                              property routing

                                                                                                                                                                                                                              routing?: string | undefined;

                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                  type?: string | undefined;

                                                                                                                                                                                                                                    property waitForActiveShards

                                                                                                                                                                                                                                    waitForActiveShards?: string | undefined;

                                                                                                                                                                                                                                      interface Cat

                                                                                                                                                                                                                                      interface Cat {}

                                                                                                                                                                                                                                        method aliases

                                                                                                                                                                                                                                        aliases: {
                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                        params: CatAliasesParams,
                                                                                                                                                                                                                                        callback: (error: any, response: any) => void
                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                        (params: CatAliasesParams): Promise<any>;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          method allocation

                                                                                                                                                                                                                                          allocation: {
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          params: CatAllocationParams,
                                                                                                                                                                                                                                          callback: (error: any, response: any) => void
                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                          (params: CatAllocationParams): Promise<any>;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method count

                                                                                                                                                                                                                                            count: {
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            params: CatCountParams,
                                                                                                                                                                                                                                            callback: (error: any, response: any) => void
                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                            (params: CatAllocationParams): Promise<any>;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method fielddata

                                                                                                                                                                                                                                              fielddata: {
                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                              params: CatFielddataParams,
                                                                                                                                                                                                                                              callback: (error: any, response: any) => void
                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                              (params: CatFielddataParams): Promise<any>;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                method health

                                                                                                                                                                                                                                                health: {
                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                params: CatHealthParams,
                                                                                                                                                                                                                                                callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                (params: CatHealthParams): Promise<any>;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  method help

                                                                                                                                                                                                                                                  help: {
                                                                                                                                                                                                                                                  (params: CatHelpParams, callback: (error: any, response: any) => void): void;
                                                                                                                                                                                                                                                  (params: CatHelpParams): Promise<any>;
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    method indices

                                                                                                                                                                                                                                                    indices: {
                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                    params: CatIndicesParams,
                                                                                                                                                                                                                                                    callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                    (params: CatIndicesParams): Promise<any>;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      method master

                                                                                                                                                                                                                                                      master: {
                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                      params: CatCommonParams,
                                                                                                                                                                                                                                                      callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                      (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        method nodeattrs

                                                                                                                                                                                                                                                        nodeattrs: {
                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                        params: CatCommonParams,
                                                                                                                                                                                                                                                        callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                        (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          method nodes

                                                                                                                                                                                                                                                          nodes: {
                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                          params: CatCommonParams,
                                                                                                                                                                                                                                                          callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                          (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method pendingTasks

                                                                                                                                                                                                                                                            pendingTasks: {
                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                            params: CatCommonParams,
                                                                                                                                                                                                                                                            callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                            (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              method plugins

                                                                                                                                                                                                                                                              plugins: {
                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                              params: CatCommonParams,
                                                                                                                                                                                                                                                              callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                              (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                method recovery

                                                                                                                                                                                                                                                                recovery: {
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                params: CatRecoveryParams,
                                                                                                                                                                                                                                                                callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                (params: CatRecoveryParams): Promise<any>;
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  method repositories

                                                                                                                                                                                                                                                                  repositories: {
                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                  params: CatCommonParams,
                                                                                                                                                                                                                                                                  callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                  (params: CatCommonParams): Promise<any>;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    method segments

                                                                                                                                                                                                                                                                    segments: {
                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                    params: CatSegmentsParams,
                                                                                                                                                                                                                                                                    callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                    (params: CatSegmentsParams): Promise<any>;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method shards

                                                                                                                                                                                                                                                                      shards: {
                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                      params: CatShardsParams,
                                                                                                                                                                                                                                                                      callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                      (params: CatShardsParams): Promise<any>;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        method snapshots

                                                                                                                                                                                                                                                                        snapshots: {
                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                        params: CatSnapshotsParams,
                                                                                                                                                                                                                                                                        callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                        (params: CatSnapshotsParams): Promise<any>;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          method tasks

                                                                                                                                                                                                                                                                          tasks: {
                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                          params: CatTasksParams,
                                                                                                                                                                                                                                                                          callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                          (params: CatTasksParams): Promise<any>;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            method threadPool

                                                                                                                                                                                                                                                                            threadPool: {
                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                            params: CatThreadPoolParams,
                                                                                                                                                                                                                                                                            callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                            (params: CatThreadPoolParams): Promise<any>;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              interface CatAliasesParams

                                                                                                                                                                                                                                                                              interface CatAliasesParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                name?: NameList | undefined;

                                                                                                                                                                                                                                                                                  interface CatAllocationParams

                                                                                                                                                                                                                                                                                  interface CatAllocationParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                    property bytes

                                                                                                                                                                                                                                                                                    bytes?: CatBytes | undefined;

                                                                                                                                                                                                                                                                                      property nodeId

                                                                                                                                                                                                                                                                                      nodeId?: NameList | undefined;

                                                                                                                                                                                                                                                                                        interface CatCommonParams

                                                                                                                                                                                                                                                                                        interface CatCommonParams extends GenericParams {}

                                                                                                                                                                                                                                                                                          property format

                                                                                                                                                                                                                                                                                          format: string;

                                                                                                                                                                                                                                                                                            property h

                                                                                                                                                                                                                                                                                            h?: NameList | undefined;

                                                                                                                                                                                                                                                                                              property help

                                                                                                                                                                                                                                                                                              help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                property local

                                                                                                                                                                                                                                                                                                local?: boolean | undefined;

                                                                                                                                                                                                                                                                                                  property masterTimeout

                                                                                                                                                                                                                                                                                                  masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                    property v

                                                                                                                                                                                                                                                                                                    v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                      interface CatCountParams

                                                                                                                                                                                                                                                                                                      interface CatCountParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                                                        index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                          interface CatFielddataParams

                                                                                                                                                                                                                                                                                                          interface CatFielddataParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                            property bytes

                                                                                                                                                                                                                                                                                                            bytes?: CatBytes | undefined;

                                                                                                                                                                                                                                                                                                              property fields

                                                                                                                                                                                                                                                                                                              fields?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                interface CatHealthParams

                                                                                                                                                                                                                                                                                                                interface CatHealthParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                                  property ts

                                                                                                                                                                                                                                                                                                                  ts?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                    interface CatHelpParams

                                                                                                                                                                                                                                                                                                                    interface CatHelpParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                      property help

                                                                                                                                                                                                                                                                                                                      help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                        interface CatIndicesParams

                                                                                                                                                                                                                                                                                                                        interface CatIndicesParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                                          property bytes

                                                                                                                                                                                                                                                                                                                          bytes?: CatBytes | undefined;

                                                                                                                                                                                                                                                                                                                            property health

                                                                                                                                                                                                                                                                                                                            health?: 'green' | 'yellow' | 'red' | undefined;

                                                                                                                                                                                                                                                                                                                              property index

                                                                                                                                                                                                                                                                                                                              index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                property pri

                                                                                                                                                                                                                                                                                                                                pri?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                  interface CatRecoveryParams

                                                                                                                                                                                                                                                                                                                                  interface CatRecoveryParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                    property bytes

                                                                                                                                                                                                                                                                                                                                    bytes?: CatBytes | undefined;

                                                                                                                                                                                                                                                                                                                                      property format

                                                                                                                                                                                                                                                                                                                                      format: string;

                                                                                                                                                                                                                                                                                                                                        property h

                                                                                                                                                                                                                                                                                                                                        h?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                          property help

                                                                                                                                                                                                                                                                                                                                          help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                            property masterTimeout

                                                                                                                                                                                                                                                                                                                                            masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                              property v

                                                                                                                                                                                                                                                                                                                                              v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                interface CatSegmentsParams

                                                                                                                                                                                                                                                                                                                                                interface CatSegmentsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                  property format

                                                                                                                                                                                                                                                                                                                                                  format: string;

                                                                                                                                                                                                                                                                                                                                                    property h

                                                                                                                                                                                                                                                                                                                                                    h?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                      property help

                                                                                                                                                                                                                                                                                                                                                      help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                                                                                                        index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                          property v

                                                                                                                                                                                                                                                                                                                                                          v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                            interface CatShardsParams

                                                                                                                                                                                                                                                                                                                                                            interface CatShardsParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                                                                              property bytes

                                                                                                                                                                                                                                                                                                                                                              bytes?: CatBytes | undefined;

                                                                                                                                                                                                                                                                                                                                                                property index

                                                                                                                                                                                                                                                                                                                                                                index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                  interface CatSnapshotsParams

                                                                                                                                                                                                                                                                                                                                                                  interface CatSnapshotsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                    property format

                                                                                                                                                                                                                                                                                                                                                                    format: string;

                                                                                                                                                                                                                                                                                                                                                                      property h

                                                                                                                                                                                                                                                                                                                                                                      h?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                        property help

                                                                                                                                                                                                                                                                                                                                                                        help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                          property ignoreUnavailable

                                                                                                                                                                                                                                                                                                                                                                          ignoreUnavailable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                            masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                              property repository

                                                                                                                                                                                                                                                                                                                                                                              repository?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                property v

                                                                                                                                                                                                                                                                                                                                                                                v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  interface CatTasksParams

                                                                                                                                                                                                                                                                                                                                                                                  interface CatTasksParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                    property actions

                                                                                                                                                                                                                                                                                                                                                                                    actions?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      property detailed

                                                                                                                                                                                                                                                                                                                                                                                      detailed?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property format

                                                                                                                                                                                                                                                                                                                                                                                        format: string;

                                                                                                                                                                                                                                                                                                                                                                                          property h

                                                                                                                                                                                                                                                                                                                                                                                          h?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property help

                                                                                                                                                                                                                                                                                                                                                                                            help?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property nodeId

                                                                                                                                                                                                                                                                                                                                                                                              nodeId?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property parentNode

                                                                                                                                                                                                                                                                                                                                                                                                parentNode?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  property parentTask

                                                                                                                                                                                                                                                                                                                                                                                                  parentTask?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property v

                                                                                                                                                                                                                                                                                                                                                                                                    v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                      interface CatThreadPoolParams

                                                                                                                                                                                                                                                                                                                                                                                                      interface CatThreadPoolParams extends CatCommonParams {}

                                                                                                                                                                                                                                                                                                                                                                                                        property size

                                                                                                                                                                                                                                                                                                                                                                                                        size?: '' | 'k' | 'm' | 'g' | 't' | 'p' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                          property threadPoolPatterns

                                                                                                                                                                                                                                                                                                                                                                                                          threadPoolPatterns?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            interface ClearScrollParams

                                                                                                                                                                                                                                                                                                                                                                                                            interface ClearScrollParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                              property scrollId

                                                                                                                                                                                                                                                                                                                                                                                                              scrollId: NameList;

                                                                                                                                                                                                                                                                                                                                                                                                                interface Cluster

                                                                                                                                                                                                                                                                                                                                                                                                                interface Cluster {}

                                                                                                                                                                                                                                                                                                                                                                                                                  method allocationExplain

                                                                                                                                                                                                                                                                                                                                                                                                                  allocationExplain: {
                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                  params: ClusterAllocationExplainParams,
                                                                                                                                                                                                                                                                                                                                                                                                                  callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                  (params: ClusterAllocationExplainParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                    method getSettings

                                                                                                                                                                                                                                                                                                                                                                                                                    getSettings: {
                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                    params: ClusterGetSettingsParams,
                                                                                                                                                                                                                                                                                                                                                                                                                    callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                    (params: ClusterGetSettingsParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                      method health

                                                                                                                                                                                                                                                                                                                                                                                                                      health: {
                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                      params: ClusterHealthParams,
                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                      (params: ClusterHealthParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                        method pendingTasks

                                                                                                                                                                                                                                                                                                                                                                                                                        pendingTasks: {
                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                        params: ClusterPendingTasksParams,
                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                        (params: ClusterPendingTasksParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                          method putSettings

                                                                                                                                                                                                                                                                                                                                                                                                                          putSettings: {
                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                          params: ClusterPutSettingsParams,
                                                                                                                                                                                                                                                                                                                                                                                                                          callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                          (params: ClusterPutSettingsParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            method reroute

                                                                                                                                                                                                                                                                                                                                                                                                                            reroute: {
                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                            params: ClusterRerouteParams,
                                                                                                                                                                                                                                                                                                                                                                                                                            callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                            (params: ClusterRerouteParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                              method state

                                                                                                                                                                                                                                                                                                                                                                                                                              state: {
                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                              params: ClusterStateParams,
                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                              (params: ClusterStateParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                method stats

                                                                                                                                                                                                                                                                                                                                                                                                                                stats: {
                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                params: ClusterStatsParams,
                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (error: any, response: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                (params: ClusterStatsParams): Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterAllocationExplainParams

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterAllocationExplainParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property includeDiskInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                    includeDiskInfo?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property includeYesDecisions

                                                                                                                                                                                                                                                                                                                                                                                                                                      includeYesDecisions?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClusterGetSettingsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClusterGetSettingsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property flatSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                          flatSettings?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property includeDefaults

                                                                                                                                                                                                                                                                                                                                                                                                                                            includeDefaults?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                              masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterHealthParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterHealthParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                    index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                      level?: 'cluster' | 'indices' | 'shards' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property local

                                                                                                                                                                                                                                                                                                                                                                                                                                                        local?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                          masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property waitForActiveShards

                                                                                                                                                                                                                                                                                                                                                                                                                                                            waitForActiveShards?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property waitForEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                              waitForEvents?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'immediate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'urgent'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'high'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'normal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'low'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'languid'
                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property waitForNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                waitForNodes?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property waitForRelocatingShards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  waitForRelocatingShards?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property waitForStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    waitForStatus?: 'green' | 'yellow' | 'red' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ClusterPendingTasksParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ClusterPendingTasksParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property local

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        local?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ClusterPutSettingsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ClusterPutSettingsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property flatSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flatSettings?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClusterRerouteParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClusterRerouteParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dryRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dryRun?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property explain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        explain?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metric

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            metric?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property retryFailed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              retryFailed?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterStateParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterStateParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property allowNoIndices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowNoIndices?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expandWildcards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expandWildcards?: ExpandWildcards | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property flatSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        flatSettings?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ignoreUnavailable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ignoreUnavailable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property local

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              local?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property masterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                masterTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metric

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metric?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClusterStatsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClusterStatsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property flatSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      flatSettings?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property human

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        human?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property nodeId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeId?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property apiVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apiVersion?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property connectionClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  connectionClass?: string | typeof HttpConnector | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property createNodeAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createNodeAgent?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property deadTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deadTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defer?: (() => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          host?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hosts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hosts?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property httpAuth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              httpAuth?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property keepAlive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keepAlive?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  log?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property maxRetries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxRetries?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property maxSockets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxSockets?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property nodesToHostCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nodesToHostCallback?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pingTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pingTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            plugins?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property requestTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selector?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sniffedNodesProtocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sniffedNodesProtocol?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sniffInterval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sniffInterval?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sniffOnConnectionFault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sniffOnConnectionFault?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sniffOnStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sniffOnStart?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ssl?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property suggestCompression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            suggestCompression?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CountParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CountParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property allowNoIndices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                allowNoIndices?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property analyzer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  analyzer?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property analyzeWildcard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    analyzeWildcard?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultOperator?: DefaultOperator | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property df

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        df?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expandWildcards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          expandWildcards?: ExpandWildcards | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ignoreUnavailable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ignoreUnavailable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lenient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lenient?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property lowercaseExpandedTerms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lowercaseExpandedTerms?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minScore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minScore?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property preference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preference?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        q?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          routing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CountResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CountResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                count: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateDocumentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateDocumentParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pipeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pipeline?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            refresh?: Refresh | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              routing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timestamp?: Date | number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ttl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ttl?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property versionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          versionType?: VersionType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property waitForActiveShards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            waitForActiveShards?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateDocumentResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateDocumentResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                created: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  result: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteDocumentByQueryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteDocumentByQueryParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowNoIndices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowNoIndices?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property analyzer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        analyzer?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property analyzeWildcard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          analyzeWildcard?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property conflicts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            conflicts?: Conflicts | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultOperator?: DefaultOperator | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property df

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                df?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property expandWildcards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expandWildcards?: ExpandWildcards | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    from?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreUnavailable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreUnavailable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property lenient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lenient?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property lowercaseExpandedTerms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lowercaseExpandedTerms?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property preference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preference?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                q?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  refresh?: Refresh | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property requestCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requestCache?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property requestsPerSecond

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestsPerSecond?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        routing?: string | string[] | boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property scroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scroll?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scrollSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scrollSize?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property searchTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              searchTimeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property searchType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchType?: 'query_then_fetch' | 'dfs_query_then_fetch' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property slices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    slices?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sort?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stats?: string | string[] | boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property terminateAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminateAfter?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property waitForActiveShards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  waitForActiveShards?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property waitForCompletion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    waitForCompletion?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteDocumentByQueryResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeleteDocumentByQueryResponse extends ReindexResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DeleteDocumentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DeleteDocumentParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                refresh?: Refresh | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  routing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeout?: TimeSpan | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property versionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          versionType?: VersionType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property waitForActiveShards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            waitForActiveShards?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteDocumentResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeleteDocumentResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property found

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                found: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  result: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteScriptParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeleteScriptParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property lang

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lang: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeleteTemplateParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeleteTemplateParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ExistsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ExistsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property preference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preference?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property realtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        realtime?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          refresh?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            routing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ExplainParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ExplainParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property analyzer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  analyzer?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property analyzeWildcard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    analyzeWildcard?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultOperator?: DefaultOperator | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property df

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        df?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lenient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lenient?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lowercaseExpandedTerms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lowercaseExpandedTerms?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preference?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property q

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      q?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property routing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        routing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property storedFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          storedFields?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ExplainResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ExplainResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property explanation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                explanation: ExplainResponseDetails;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property matched

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  matched: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ExplainResponseDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ExplainResponseDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        details: ExplainResponseDetails[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Explanation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Explanation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                details: Explanation[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FieldStatsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FieldStatsParams extends GenericParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowNoIndices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowNoIndices?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property expandWildcards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        expandWildcards?: ExpandWildcards | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fields?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ignoreUnavailable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ignoreUnavailable?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index?: NameList | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                level?: 'indices' | 'cluster' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FieldStatsResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FieldStatsResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property conflicts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    conflicts?: { [fieldName: string]: string } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property indices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      indices: { [indexName: string]: FieldStatsResponseIndex }