@types/elasticsearch

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 };

interface FieldStatsResponseField

interface FieldStatsResponseField {}

property density

density: number;

property doc_count

doc_count: number;

property is_aggregatable

is_aggregatable: string;

property is_searchable

is_searchable: string;

property max_doc

max_doc: number;

property max_value

max_value: any;

property min_value

min_value: any;

property sum_doc_freq

sum_doc_freq: number;

property sum_total_term_freq

sum_total_term_freq: number;

interface FieldStatsResponseIndex

interface FieldStatsResponseIndex {}

property fields

fields: { [fieldName: string]: FieldStatsResponseField };

interface GenericParams

interface GenericParams {}

property body

body?: any;

property filterPath

filterPath?: string | string[] | undefined;

property ignore

ignore?: number | number[] | undefined;

property maxRetries

maxRetries?: number | undefined;

property method

method?: string | undefined;

@types/elasticsearch

Install

Overview

Index

Classes

Interfaces

Type Aliases

Namespaces

Classes

class Client

constructor

property cat

property cluster

property indices

property ingest

property nodes

property snapshot

property tasks

method bulk

method clearScroll

method close

method count

method create

method delete

method deleteByQuery

method deleteScript

method deleteTemplate

method exists

method explain

method fieldStats

method get

method getScript

method getSource

method getTemplate

method index

method info

method mget

method msearch

method msearchTemplate

method mtermvectors

method ping

method putScript

method putTemplate

method reindex

method reindexRethrottle

method renderSearchTemplate

method scroll

method search

method searchShards

method searchTemplate

method suggest

method termvectors

method update

method updateByQuery

class Indices

method analyze

method clearCache

method close

method create

method delete

method deleteAlias

method deleteTemplate

method exists

method existsAlias

method existsTemplate

method existsType

method flush

method flushSynced

method forcemerge

method get

method getAlias

method getFieldMapping

method getMapping

method getSettings

method getTemplate

method getUpgrade

method open

method putAlias

method putMapping

method putSettings