mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
ae863e389d
As described in Elasticsearch documentation - https://www.elastic.co/guide/en/elasticsearch/reference/current/cat-shards.html#cat-shards-query-params
1682 lines
55 KiB
TypeScript
1682 lines
55 KiB
TypeScript
// Type definitions for elasticsearch 5.0
|
|
// Project: https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/16.x/index.html
|
|
// Definitions by: Casper Skydt <https://github.com/CasperSkydt>
|
|
// Blake Smith <https://github.com/bfsmith>
|
|
// Dave Dunkin <https://github.com/ddunkin>
|
|
// Jeffery Grajkowski <https://github.com/pushplay>
|
|
// Margus Lamp <https://github.com/mlamp>
|
|
// Ahmad Ferdous Bin Alam <https://github.com/ahmadferdous>
|
|
// Simon Schick <https://github.com/SimonSchick>
|
|
// Paul Brabban <https://github.com/brabster>
|
|
// Budi Irawan <https://github.com/deerawan>
|
|
// Yonatan Kiron <https://github.com/YonatanKiron>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
// TypeScript Version: 2.2
|
|
|
|
import HttpConnector = require("./src/lib/connectors/http");
|
|
|
|
export class Client {
|
|
constructor(params: ConfigOptions);
|
|
cat: Cat;
|
|
cluster: Cluster;
|
|
indices: Indices;
|
|
ingest: Ingest;
|
|
nodes: Nodes;
|
|
snapshot: Snapshot;
|
|
tasks: Tasks;
|
|
bulk(params: BulkIndexDocumentsParams, callback: (error: any, response: any) => void): void;
|
|
bulk(params: BulkIndexDocumentsParams): Promise<any>;
|
|
clearScroll(params: ClearScrollParams, callback: (error: any, response: any) => void): void;
|
|
clearScroll(params: ClearScrollParams): Promise<any>;
|
|
count(params: CountParams, callback: (error: any, response: CountResponse) => void): void;
|
|
count(params: CountParams): Promise<CountResponse>;
|
|
create(params: CreateDocumentParams, callback: (err: any, response: CreateDocumentResponse, status: any) => void): void;
|
|
create(params: CreateDocumentParams): Promise<CreateDocumentResponse>;
|
|
delete(params: DeleteDocumentParams, callback: (error: any, response: DeleteDocumentResponse) => void): void;
|
|
delete(params: DeleteDocumentParams): Promise<DeleteDocumentResponse>;
|
|
deleteByQuery(params: DeleteDocumentByQueryParams, callback: (error: any, response: DeleteDocumentByQueryResponse) => void): void;
|
|
deleteByQuery(params: DeleteDocumentByQueryParams): Promise<DeleteDocumentByQueryResponse>;
|
|
deleteScript(params: DeleteScriptParams, callback: (error: any, response: any) => void): void;
|
|
deleteScript(params: DeleteScriptParams): Promise<any>;
|
|
deleteTemplate(params: DeleteTemplateParams, callback: (error: any, response: any) => void): void;
|
|
deleteTemplate(params: DeleteTemplateParams): Promise<any>;
|
|
exists(params: ExistsParams, callback: (error: any, response: boolean, status?: any) => void): void;
|
|
exists(params: ExistsParams): Promise<boolean>;
|
|
explain(params: ExplainParams, callback: (error: any, response: ExplainResponse) => void): void;
|
|
explain(params: ExplainParams): Promise<ExplainResponse>;
|
|
fieldStats(params: FieldStatsParams, callback: (error: any, response: FieldStatsResponse) => void): void;
|
|
fieldStats(params: FieldStatsParams): Promise<FieldStatsResponse>;
|
|
get<T>(params: GetParams, callback: (error: any, response: GetResponse<T>) => void): void;
|
|
get<T>(params: GetParams): Promise<GetResponse<T>>;
|
|
getScript(params: GetScriptParams, callback: (error: any, response: any) => void): void;
|
|
getScript(params: GetScriptParams): Promise<any>;
|
|
getSource(params: GetSourceParams, callback: (error: any, response: any) => void): void;
|
|
getSource(params: GetSourceParams): Promise<any>;
|
|
getTemplate(params: GetTemplateParams, callback: (error: any, response: any) => void): void;
|
|
getTemplate(params: GetTemplateParams): Promise<any>;
|
|
index<T>(params: IndexDocumentParams<T>, callback: (error: any, response: any) => void): void;
|
|
index<T>(params: IndexDocumentParams<T>): Promise<any>;
|
|
info(params: InfoParams, callback: (error: any, response: any) => void): void;
|
|
info(params: InfoParams): Promise<any>;
|
|
mget<T>(params: MGetParams, callback: (error: any, response: MGetResponse<T>) => void): void;
|
|
mget<T>(params: MGetParams): Promise<MGetResponse<T>>;
|
|
msearch<T>(params: MSearchParams, callback: (error: any, response: MSearchResponse<T>) => void): void;
|
|
msearch<T>(params: MSearchParams): Promise<MSearchResponse<T>>;
|
|
msearchTemplate<T>(params: MSearchTemplateParams, callback: (error: any, response: MSearchResponse<T>) => void): void;
|
|
msearchTemplate<T>(params: MSearchTemplateParams): Promise<MSearchResponse<T>>;
|
|
mtermvectors(params: MTermVectorsParams, callback: (error: any, response: any) => void): void;
|
|
mtermvectors(params: MTermVectorsParams): Promise<any>;
|
|
ping(params: PingParams, callback: (err: any, response: any, status: any) => void): void;
|
|
ping(params: PingParams): Promise<any>;
|
|
putScript(params: PutScriptParams, callback: (err: any, response: any, status: any) => void): void;
|
|
putScript(params: PutScriptParams): Promise<any>;
|
|
putTemplate(params: PutTemplateParams, callback: (err: any, response: any, status: any) => void): void;
|
|
putTemplate(params: PutTemplateParams): Promise<any>;
|
|
reindex(params: ReindexParams, callback: (error: any, response: ReindexResponse) => void): void;
|
|
reindex(params: ReindexParams): Promise<ReindexResponse>;
|
|
reindexRethrottle(params: ReindexRethrottleParams, callback: (error: any, response: any) => void): void;
|
|
reindexRethrottle(params: ReindexRethrottleParams): Promise<any>;
|
|
renderSearchTemplate(params: RenderSearchTemplateParams, callback: (error: any, response: any) => void): void;
|
|
renderSearchTemplate(params: RenderSearchTemplateParams): Promise<any>;
|
|
scroll<T>(params: ScrollParams, callback: (error: any, response: SearchResponse<T>) => void): void;
|
|
scroll<T>(params: ScrollParams): Promise<SearchResponse<T>>;
|
|
search<T>(params: SearchParams, callback: (error: any, response: SearchResponse<T>) => void): void;
|
|
search<T>(params: SearchParams): Promise<SearchResponse<T>>;
|
|
searchShards(params: SearchShardsParams, callback: (error: any, response: SearchShardsResponse) => void): void;
|
|
searchShards(params: SearchShardsParams): Promise<SearchShardsResponse>;
|
|
searchTemplate(params: SearchTemplateParams, callback: (error: any, response: any) => void): void;
|
|
searchTemplate(params: SearchTemplateParams): Promise<any>;
|
|
suggest(params: SuggestParams, callback: (error: any, response: any) => void): void;
|
|
suggest(params: SuggestParams): Promise<any>;
|
|
termvectors(params: TermvectorsParams, callback: (error: any, response: any) => void): void;
|
|
termvectors(params: TermvectorsParams): Promise<any>;
|
|
update(params: UpdateDocumentParams, callback: (error: any, response: any) => void): void;
|
|
update(params: UpdateDocumentParams): Promise<any>;
|
|
updateByQuery(params: UpdateDocumentByQueryParams, callback: (error: any, response: UpdateDocumentByQueryResponse) => void): void;
|
|
updateByQuery(params: UpdateDocumentByQueryParams): Promise<UpdateDocumentByQueryResponse>;
|
|
close(): void;
|
|
}
|
|
|
|
export interface ConfigOptions {
|
|
host?: any;
|
|
hosts?: any;
|
|
httpAuth?: string;
|
|
log?: any;
|
|
apiVersion?: string;
|
|
plugins?: any;
|
|
sniffOnStart?: boolean;
|
|
sniffInterval?: number;
|
|
sniffOnConnectionFault?: boolean;
|
|
maxRetries?: number;
|
|
requestTimeout?: number;
|
|
deadTimeout?: number;
|
|
pingTimeout?: number;
|
|
keepAlive?: boolean;
|
|
maxSockets?: number;
|
|
suggestCompression?: boolean;
|
|
connectionClass?: string | typeof HttpConnector;
|
|
sniffedNodesProtocol?: string;
|
|
ssl?: object;
|
|
selector?: any;
|
|
defer?: () => void;
|
|
nodesToHostCallback?: any;
|
|
createNodeAgent?: any;
|
|
}
|
|
|
|
export interface Explanation {
|
|
value: number;
|
|
description: string;
|
|
details: Explanation[];
|
|
}
|
|
|
|
export interface GenericParams {
|
|
requestTimeout?: number;
|
|
maxRetries?: number;
|
|
method?: string;
|
|
body?: any;
|
|
ignore?: number | number[];
|
|
filterPath?: string | string[];
|
|
}
|
|
|
|
export interface ShardsResponse {
|
|
total: number;
|
|
successful: number;
|
|
failed: number;
|
|
skipped: number;
|
|
}
|
|
|
|
/**
|
|
* A string of a number and a time unit. A time unit is one of
|
|
* [d, h, m, s, ms, micros, nanos]. eg: "30s" for 30 seconds.
|
|
* These are incorrectly identified as `Date | number` in the docs as of 2016-11-15.
|
|
*/
|
|
export type TimeSpan = string;
|
|
|
|
export type NameList = string | string[] | boolean;
|
|
export type Refresh = boolean | "true" | "false" | "wait_for" | "";
|
|
export type VersionType = "internal" | "external" | "external_gte" | "force";
|
|
export type ExpandWildcards = "open" | "closed" | "none" | "all";
|
|
export type DefaultOperator = "AND" | "OR";
|
|
export type Conflicts = "abort" | "proceed";
|
|
|
|
export interface BulkIndexDocumentsParams extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
refresh?: Refresh;
|
|
routing?: string;
|
|
timeout?: TimeSpan;
|
|
type?: string;
|
|
fields?: NameList;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
pipeline?: string;
|
|
index?: string;
|
|
}
|
|
|
|
export interface ClearScrollParams extends GenericParams {
|
|
scrollId: NameList;
|
|
}
|
|
|
|
export interface CountParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
minScore?: number;
|
|
preference?: string;
|
|
routing?: string;
|
|
q?: string;
|
|
analyzer?: string;
|
|
analyzeWildcard?: boolean;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
index?: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export interface CountResponse {
|
|
count: number;
|
|
_shards: ShardsResponse;
|
|
}
|
|
|
|
export interface CreateDocumentParams extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
parent?: string;
|
|
refresh?: Refresh;
|
|
routing?: string;
|
|
timeout?: TimeSpan;
|
|
timestamp?: Date | number;
|
|
ttl?: TimeSpan;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
pipeline?: string;
|
|
id?: string;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface CreateDocumentResponse {
|
|
_shards: ShardsResponse;
|
|
_index: string;
|
|
_type: string;
|
|
_id: string;
|
|
_version: number;
|
|
created: boolean;
|
|
result: string;
|
|
}
|
|
|
|
export interface DeleteDocumentParams extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
parent?: string;
|
|
refresh?: Refresh;
|
|
routing?: string;
|
|
timeout?: TimeSpan;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
index: string;
|
|
type: string;
|
|
id: string;
|
|
}
|
|
|
|
export interface DeleteDocumentResponse {
|
|
_shards: ShardsResponse;
|
|
found: boolean;
|
|
_index: string;
|
|
_type: string;
|
|
_id: string;
|
|
_version: number;
|
|
result: string;
|
|
}
|
|
|
|
export interface DeleteDocumentByQueryParams extends GenericParams {
|
|
analyzer?: string;
|
|
analyzeWildcard?: boolean;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
from?: number;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
conflicts?: Conflicts;
|
|
expandWildcards?: ExpandWildcards;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
preference?: string;
|
|
q?: string;
|
|
routing?: string | string[] | boolean;
|
|
scroll?: string;
|
|
searchType?: "query_then_fetch" | "dfs_query_then_fetch";
|
|
searchTimeout?: TimeSpan;
|
|
size?: number;
|
|
sort?: NameList;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
terminateAfter?: number;
|
|
stats?: string | string[] | boolean;
|
|
version?: number;
|
|
requestCache?: boolean;
|
|
refresh?: Refresh;
|
|
timeout?: TimeSpan;
|
|
waitForActiveShards?: string;
|
|
scrollSize?: number;
|
|
waitForCompletion?: boolean;
|
|
requestsPerSecond?: number;
|
|
slices?: number;
|
|
index?: string;
|
|
type?: string;
|
|
}
|
|
|
|
export interface DeleteDocumentByQueryResponse extends ReindexResponse {
|
|
// DeleteDocumentByQueryResponse, UpdateDocumentByQueryResponse and ReindexResponse are identical
|
|
}
|
|
|
|
export interface DeleteScriptParams extends GenericParams {
|
|
id: string;
|
|
lang: string;
|
|
}
|
|
|
|
export interface DeleteTemplateParams extends GenericParams {
|
|
id: string;
|
|
}
|
|
|
|
export interface ExistsParams extends GenericParams {
|
|
parent?: string;
|
|
preference?: string;
|
|
realtime?: boolean;
|
|
refresh?: boolean;
|
|
routing?: string;
|
|
id: string;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface ExplainParams extends GenericParams {
|
|
analyzeWildcard?: boolean;
|
|
analyzer?: string;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
storedFields?: NameList;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
parent?: string;
|
|
preference?: string;
|
|
q?: string;
|
|
routing?: string;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
id?: string;
|
|
index?: string;
|
|
type?: string;
|
|
}
|
|
|
|
export interface ExplainResponse {
|
|
_index: string;
|
|
_type: string;
|
|
_id: string;
|
|
matched: boolean;
|
|
explanation: ExplainResponseDetails;
|
|
}
|
|
|
|
export interface ExplainResponseDetails {
|
|
value: number;
|
|
description: string;
|
|
details: ExplainResponseDetails[];
|
|
}
|
|
|
|
export interface FieldStatsParams extends GenericParams {
|
|
fields?: NameList;
|
|
level?: "indices" | "cluster";
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface FieldStatsResponse {
|
|
_shards: ShardsResponse;
|
|
indices: { [indexName: string]: FieldStatsResponseIndex };
|
|
conflicts?: { [fieldName: string]: string };
|
|
}
|
|
|
|
export interface FieldStatsResponseIndex {
|
|
fields: { [fieldName: string]: FieldStatsResponseField };
|
|
}
|
|
|
|
export interface FieldStatsResponseField {
|
|
max_doc: number;
|
|
doc_count: number;
|
|
density: number;
|
|
sum_doc_freq: number;
|
|
sum_total_term_freq: number;
|
|
min_value: any;
|
|
max_value: any;
|
|
is_searchable: string;
|
|
is_aggregatable: string;
|
|
}
|
|
|
|
export interface GetParams extends GenericParams {
|
|
storedFields?: NameList;
|
|
parent?: string;
|
|
preference?: string;
|
|
realtime?: boolean;
|
|
refresh?: boolean;
|
|
routing?: string;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
id: string;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface GetResponse<T> {
|
|
_index: string;
|
|
_type: string;
|
|
_id: string;
|
|
_version: number;
|
|
_routing?: string;
|
|
found: boolean;
|
|
_source: T;
|
|
}
|
|
|
|
export interface GetScriptParams extends GenericParams {
|
|
id: string;
|
|
lang: string;
|
|
}
|
|
|
|
export interface GetSourceParams extends GenericParams {
|
|
preference?: string;
|
|
realtime?: boolean;
|
|
refresh?: boolean;
|
|
routing?: string;
|
|
_source: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
id: string;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface GetTemplateParams extends GenericParams {
|
|
id: string;
|
|
}
|
|
|
|
export interface IndexDocumentParams<T> extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
opType?: "index" | "create";
|
|
parent?: string;
|
|
refresh?: Refresh;
|
|
routing?: string;
|
|
timeout?: TimeSpan;
|
|
timestamp?: Date | number;
|
|
ttl?: TimeSpan;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
pipeline?: string;
|
|
id?: string;
|
|
index: string;
|
|
type: string;
|
|
body: T;
|
|
}
|
|
|
|
export interface InfoParams extends GenericParams {
|
|
}
|
|
|
|
export interface MGetParams extends GenericParams {
|
|
storedFields?: NameList;
|
|
preference?: string;
|
|
realtime?: boolean;
|
|
refresh?: boolean;
|
|
routing?: string;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
index?: string;
|
|
type?: string;
|
|
}
|
|
|
|
export interface MGetResponse<T> {
|
|
docs?: Array<GetResponse<T>>;
|
|
}
|
|
|
|
export interface MSearchParams extends GenericParams {
|
|
search_type?: "query_then_fetch" | "query_and_fetch" | "dfs_query_then_fetch" | "dfs_query_and_fetch";
|
|
maxConcurrentSearches?: number;
|
|
index?: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export interface MSearchResponse<T> {
|
|
responses?: Array<SearchResponse<T>>;
|
|
}
|
|
|
|
export interface MSearchTemplateParams extends GenericParams {
|
|
search_type?: "query_then_fetch" | "query_and_fetch" | "dfs_query_then_fetch" | "dfs_query_and_fetch";
|
|
index?: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export interface MTermVectorsParams extends GenericParams {
|
|
ids?: NameList;
|
|
termStatistics?: boolean;
|
|
fieldStatistics?: boolean;
|
|
fields?: NameList;
|
|
offsets?: boolean;
|
|
positions?: boolean;
|
|
payloads?: boolean;
|
|
preference?: string;
|
|
routing?: string;
|
|
parent?: string;
|
|
realtime?: boolean;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface PingParams extends GenericParams {
|
|
}
|
|
|
|
export interface PutScriptParams extends GenericParams {
|
|
id: string;
|
|
lang: string;
|
|
body: any;
|
|
}
|
|
|
|
export interface PutTemplateParams extends GenericParams {
|
|
id: string;
|
|
body: any;
|
|
}
|
|
|
|
export interface ReindexParams extends GenericParams {
|
|
refresh?: boolean;
|
|
timeout?: TimeSpan;
|
|
waitForActiveShards?: string;
|
|
waitForCompletion?: boolean;
|
|
requestsPerSecond?: number;
|
|
slices?: number;
|
|
body: {
|
|
conflicts?: string;
|
|
source: {
|
|
index: string | string[];
|
|
type?: string | string[];
|
|
query?: any;
|
|
sort?: any;
|
|
size?: number;
|
|
remote?: {
|
|
host: string;
|
|
username?: string;
|
|
password?: string;
|
|
}
|
|
};
|
|
dest: {
|
|
index: string;
|
|
version_type?: string;
|
|
op_type?: string;
|
|
routing?: string;
|
|
pipeline?: string;
|
|
};
|
|
script?: {
|
|
inline: string;
|
|
lang: string;
|
|
}
|
|
};
|
|
}
|
|
|
|
export interface ReindexRethrottleParams extends GenericParams {
|
|
requestsPerSecond: number;
|
|
taskId: string;
|
|
}
|
|
|
|
export interface RenderSearchTemplateParams extends GenericParams {
|
|
id: string;
|
|
}
|
|
|
|
export interface ScrollParams extends GenericParams {
|
|
scroll: TimeSpan;
|
|
scrollId: string;
|
|
}
|
|
|
|
export interface SearchParams extends GenericParams {
|
|
analyzer?: string;
|
|
analyzeWildcard?: boolean;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
explain?: boolean;
|
|
storedFields?: NameList;
|
|
docvalueFields?: NameList;
|
|
fielddataFields?: NameList;
|
|
from?: number;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
preference?: string;
|
|
q?: string;
|
|
routing?: NameList;
|
|
scroll?: TimeSpan;
|
|
searchType?: "query_then_fetch" | "dfs_query_then_fetch";
|
|
size?: number;
|
|
sort?: NameList;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
terminateAfter?: number;
|
|
stats?: NameList;
|
|
suggestField?: string;
|
|
suggestMode?: "missing" | "popular" | "always";
|
|
suggestSize?: number;
|
|
suggestText?: string;
|
|
timeout?: TimeSpan;
|
|
trackScores?: boolean;
|
|
version?: boolean;
|
|
requestCache?: boolean;
|
|
index?: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export interface SearchResponse<T> {
|
|
took: number;
|
|
timed_out: boolean;
|
|
_scroll_id?: string;
|
|
_shards: ShardsResponse;
|
|
hits: {
|
|
total: number;
|
|
max_score: number;
|
|
hits: Array<{
|
|
_index: string;
|
|
_type: string;
|
|
_id: string;
|
|
_score: number;
|
|
_source: T;
|
|
_version?: number;
|
|
_explanation?: Explanation;
|
|
fields?: any;
|
|
highlight?: any;
|
|
inner_hits?: any;
|
|
matched_queries?: string[];
|
|
sort?: string[];
|
|
}>;
|
|
};
|
|
aggregations?: any;
|
|
}
|
|
|
|
export interface SearchShardsParams extends GenericParams {
|
|
preference?: string;
|
|
routing?: string;
|
|
local?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index: NameList;
|
|
type: NameList;
|
|
}
|
|
|
|
export interface SearchShardsResponse {
|
|
nodes: any;
|
|
shards: SearchShardsResponseShard[][];
|
|
}
|
|
|
|
export interface SearchShardsResponseShard {
|
|
index: string;
|
|
node: string;
|
|
primary: boolean;
|
|
share: number;
|
|
state: string;
|
|
allocation_id: {
|
|
id: string;
|
|
};
|
|
relocating_node: any;
|
|
}
|
|
|
|
export interface SearchTemplateParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
preference?: string;
|
|
routing?: NameList;
|
|
scroll?: TimeSpan;
|
|
searchType?: "query_then_fetch" | "query_and_fetch" | "dfs_query_then_fetch" | "dfs_query_and_fetch";
|
|
index: NameList;
|
|
type: NameList;
|
|
}
|
|
|
|
export interface SuggestParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
preference?: string;
|
|
routing?: string;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface TermvectorsParams extends GenericParams {
|
|
termStatistics?: boolean;
|
|
fieldStatistics?: boolean;
|
|
fields?: NameList;
|
|
offsets?: boolean;
|
|
positions?: boolean;
|
|
payloads?: boolean;
|
|
preference?: string;
|
|
routing?: string;
|
|
parent?: string;
|
|
realtime?: boolean;
|
|
version?: number;
|
|
versionType?: VersionType;
|
|
index: string;
|
|
type: string;
|
|
id?: string;
|
|
}
|
|
|
|
export interface UpdateDocumentParams extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
fields?: NameList;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
lang?: string;
|
|
parent?: string;
|
|
refresh?: Refresh;
|
|
retryOnConflict?: number;
|
|
routing?: string;
|
|
timeout?: TimeSpan;
|
|
timestamp?: Date | number;
|
|
ttl?: TimeSpan;
|
|
version?: number;
|
|
versionType?: "internal" | "force";
|
|
id: string;
|
|
index: string;
|
|
type: string;
|
|
}
|
|
|
|
export interface UpdateDocumentByQueryParams extends GenericParams {
|
|
analyzer?: string;
|
|
analyzeWildcard?: boolean;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
explain?: boolean;
|
|
storedFields?: NameList;
|
|
docvalueFields?: NameList;
|
|
fielddataFields?: NameList;
|
|
from?: number;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
conflicts?: Conflicts;
|
|
expandWildcards?: ExpandWildcards;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
pipeline?: string;
|
|
preference?: string;
|
|
q?: string;
|
|
routing?: NameList;
|
|
scroll?: TimeSpan;
|
|
searchType?: "query_then_fetch" | "dfs_query_then_fetch";
|
|
searchTimeout?: TimeSpan;
|
|
size?: number;
|
|
sort?: NameList;
|
|
_source?: NameList;
|
|
_sourceExclude?: NameList;
|
|
_sourceInclude?: NameList;
|
|
terminateAfter?: number;
|
|
stats?: NameList;
|
|
suggestField?: string;
|
|
suggestMode?: "missing" | "popular" | "always";
|
|
suggestSize?: number;
|
|
suggestText?: string;
|
|
timeout?: TimeSpan;
|
|
trackScores?: boolean;
|
|
version?: boolean;
|
|
versionType?: boolean;
|
|
requestCache?: boolean;
|
|
refresh?: boolean;
|
|
waitForActiveShards?: string;
|
|
scrollSize?: number;
|
|
waitForCompletion?: boolean;
|
|
requestsPerSecond?: number;
|
|
slices?: number;
|
|
index: NameList;
|
|
type: NameList;
|
|
}
|
|
|
|
export interface UpdateDocumentByQueryResponse extends ReindexResponse {
|
|
// DeleteDocumentByQueryResponse, UpdateDocumentByQueryResponse and ReindexResponse are identical
|
|
}
|
|
|
|
export interface ReindexResponse extends ReindexResponseBase {
|
|
took: number;
|
|
timed_out: boolean;
|
|
failures: any[];
|
|
slices?: ReindexOrByQueryResponseSlice[];
|
|
}
|
|
|
|
export interface ReindexOrByQueryResponseSlice extends ReindexResponseBase {
|
|
slice_id: number;
|
|
}
|
|
|
|
export interface ReindexResponseBase {
|
|
total: number;
|
|
updated: number;
|
|
deleted: number;
|
|
batches: number;
|
|
version_conflicts: number;
|
|
noops: number;
|
|
retries: {
|
|
bulk: number;
|
|
search: number;
|
|
};
|
|
throttled_millis: number;
|
|
requests_per_second: number;
|
|
throttled_until_millis: number;
|
|
}
|
|
|
|
export interface Cat {
|
|
aliases(params: CatAliasesParams, callback: (error: any, response: any) => void): void;
|
|
aliases(params: CatAliasesParams): Promise<any>;
|
|
allocation(params: CatAllocationParams, callback: (error: any, response: any) => void): void;
|
|
allocation(params: CatAllocationParams): Promise<any>;
|
|
count(params: CatCountParams, callback: (error: any, response: any) => void): void;
|
|
count(params: CatAllocationParams): Promise<any>;
|
|
fielddata(params: CatFielddataParams, callback: (error: any, response: any) => void): void;
|
|
fielddata(params: CatFielddataParams): Promise<any>;
|
|
health(params: CatHealthParams, callback: (error: any, response: any) => void): void;
|
|
health(params: CatHealthParams): Promise<any>;
|
|
help(params: CatHelpParams, callback: (error: any, response: any) => void): void;
|
|
help(params: CatHelpParams): Promise<any>;
|
|
indices(params: CatIndicesParams, callback: (error: any, response: any) => void): void;
|
|
indices(params: CatIndicesParams): Promise<any>;
|
|
master(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
master(params: CatCommonParams): Promise<any>;
|
|
nodeattrs(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
nodeattrs(params: CatCommonParams): Promise<any>;
|
|
nodes(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
nodes(params: CatCommonParams): Promise<any>;
|
|
pendingTasks(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
pendingTasks(params: CatCommonParams): Promise<any>;
|
|
plugins(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
plugins(params: CatCommonParams): Promise<any>;
|
|
recovery(params: CatRecoveryParams, callback: (error: any, response: any) => void): void;
|
|
recovery(params: CatRecoveryParams): Promise<any>;
|
|
repositories(params: CatCommonParams, callback: (error: any, response: any) => void): void;
|
|
repositories(params: CatCommonParams): Promise<any>;
|
|
segments(params: CatSegmentsParams, callback: (error: any, response: any) => void): void;
|
|
segments(params: CatSegmentsParams): Promise<any>;
|
|
shards(params: CatShardsParams, callback: (error: any, response: any) => void): void;
|
|
shards(params: CatShardsParams): Promise<any>;
|
|
snapshots(params: CatSnapshotsParams, callback: (error: any, response: any) => void): void;
|
|
snapshots(params: CatSnapshotsParams): Promise<any>;
|
|
tasks(params: CatTasksParams, callback: (error: any, response: any) => void): void;
|
|
tasks(params: CatTasksParams): Promise<any>;
|
|
threadPool(params: CatThreadPoolParams, callback: (error: any, response: any) => void): void;
|
|
threadPool(params: CatThreadPoolParams): Promise<any>;
|
|
}
|
|
|
|
export type CatBytes = "b" | "k" | "kb" | "m" | "mb" | "g" | "gb" | "t" | "tb" | "p" | "pb";
|
|
|
|
export interface CatCommonParams extends GenericParams {
|
|
format: string;
|
|
local?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
h?: NameList;
|
|
help?: boolean;
|
|
v?: boolean;
|
|
}
|
|
|
|
export interface CatAliasesParams extends CatCommonParams {
|
|
name?: NameList;
|
|
}
|
|
|
|
export interface CatAllocationParams extends CatCommonParams {
|
|
bytes?: CatBytes;
|
|
nodeId?: NameList;
|
|
}
|
|
|
|
export interface CatCountParams extends CatCommonParams {
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface CatFielddataParams extends CatCommonParams {
|
|
bytes?: CatBytes;
|
|
fields?: NameList;
|
|
}
|
|
|
|
export interface CatHealthParams extends CatCommonParams {
|
|
ts?: boolean;
|
|
}
|
|
|
|
export interface CatHelpParams extends GenericParams {
|
|
help?: boolean;
|
|
}
|
|
|
|
export interface CatIndicesParams extends CatCommonParams {
|
|
bytes?: CatBytes;
|
|
health?: "green" | "yellow" | "red";
|
|
pri?: boolean;
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface CatRecoveryParams extends GenericParams {
|
|
format: string;
|
|
bytes?: CatBytes;
|
|
masterTimeout?: TimeSpan;
|
|
h?: NameList;
|
|
help?: boolean;
|
|
v?: boolean;
|
|
}
|
|
|
|
export interface CatSegmentsParams extends GenericParams {
|
|
format: string;
|
|
h?: NameList;
|
|
help?: boolean;
|
|
v?: boolean;
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface CatShardsParams extends CatCommonParams {
|
|
index?: NameList;
|
|
bytes?: CatBytes;
|
|
}
|
|
|
|
export interface CatSnapshotsParams extends GenericParams {
|
|
format: string;
|
|
ignoreUnavailable?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
h?: NameList;
|
|
help?: boolean;
|
|
v?: boolean;
|
|
repository?: NameList;
|
|
}
|
|
|
|
export interface CatTasksParams extends GenericParams {
|
|
format: string;
|
|
nodeId?: NameList;
|
|
actions?: NameList;
|
|
detailed?: boolean;
|
|
parentNode?: string;
|
|
parentTask?: number;
|
|
h?: NameList;
|
|
help?: boolean;
|
|
v?: boolean;
|
|
}
|
|
|
|
export interface CatThreadPoolParams extends CatCommonParams {
|
|
size?: "" | "k" | "m" | "g" | "t" | "p";
|
|
threadPoolPatterns?: NameList;
|
|
}
|
|
|
|
export interface Cluster {
|
|
allocationExplain(params: ClusterAllocationExplainParams, callback: (error: any, response: any) => void): void;
|
|
allocationExplain(params: ClusterAllocationExplainParams): Promise<any>;
|
|
getSettings(params: ClusterGetSettingsParams, callback: (error: any, response: any) => void): void;
|
|
getSettings(params: ClusterGetSettingsParams): Promise<any>;
|
|
health(params: ClusterHealthParams, callback: (error: any, response: any) => void): void;
|
|
health(params: ClusterHealthParams): Promise<any>;
|
|
pendingTasks(params: ClusterPendingTasksParams, callback: (error: any, response: any) => void): void;
|
|
pendingTasks(params: ClusterPendingTasksParams): Promise<any>;
|
|
putSettings(params: ClusterPutSettingsParams, callback: (error: any, response: any) => void): void;
|
|
putSettings(params: ClusterPutSettingsParams): Promise<any>;
|
|
reroute(params: ClusterRerouteParams, callback: (error: any, response: any) => void): void;
|
|
reroute(params: ClusterRerouteParams): Promise<any>;
|
|
state(params: ClusterStateParams, callback: (error: any, response: any) => void): void;
|
|
state(params: ClusterStateParams): Promise<any>;
|
|
stats(params: ClusterStatsParams, callback: (error: any, response: any) => void): void;
|
|
stats(params: ClusterStatsParams): Promise<any>;
|
|
}
|
|
|
|
export interface ClusterAllocationExplainParams extends GenericParams {
|
|
includeYesDecisions?: boolean;
|
|
includeDiskInfo?: boolean;
|
|
}
|
|
|
|
export interface ClusterGetSettingsParams extends GenericParams {
|
|
flatSettings?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
includeDefaults?: boolean;
|
|
}
|
|
|
|
export interface ClusterHealthParams extends GenericParams {
|
|
level?: "cluster" | "indices" | "shards";
|
|
local?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
waitForActiveShards?: string;
|
|
waitForNodes?: string;
|
|
waitForEvents?: "immediate" | "urgent" | "high" | "normal" | "low" | "languid";
|
|
waitForRelocatingShards?: boolean;
|
|
waitForStatus?: "green" | "yellow" | "red";
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface ClusterPendingTasksParams extends GenericParams {
|
|
local?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
}
|
|
|
|
export interface ClusterPutSettingsParams extends GenericParams {
|
|
flatSettings?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
}
|
|
|
|
export interface ClusterRerouteParams extends GenericParams {
|
|
dryRun?: boolean;
|
|
explain?: boolean;
|
|
retryFailed?: boolean;
|
|
metric?: NameList;
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
}
|
|
|
|
export interface ClusterStateParams extends GenericParams {
|
|
local?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
flatSettings?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index?: NameList;
|
|
metric?: NameList;
|
|
}
|
|
|
|
export interface ClusterStatsParams extends GenericParams {
|
|
flatSettings?: boolean;
|
|
human?: boolean;
|
|
timeout?: TimeSpan;
|
|
nodeId?: NameList;
|
|
}
|
|
|
|
export class Indices {
|
|
analyze(params: IndicesAnalyzeParams, callback: (error: any, response: any, status: any) => void): void;
|
|
analyze(params: IndicesAnalyzeParams): Promise<any>;
|
|
clearCache(params: IndicesClearCacheParams, callback: (error: any, response: any, status: any) => void): void;
|
|
clearCache(params: IndicesClearCacheParams): Promise<any>;
|
|
close(params: IndicesCloseParams, callback: (error: any, response: any, status: any) => void): void;
|
|
close(params: IndicesCloseParams): Promise<any>;
|
|
create(params: IndicesCreateParams, callback: (error: any, response: any, status: any) => void): void;
|
|
create(params: IndicesCreateParams): Promise<any>;
|
|
delete(params: IndicesDeleteParams, callback: (error: any, response: any, status: any) => void): void;
|
|
delete(params: IndicesDeleteParams): Promise<any>;
|
|
deleteAlias(params: IndicesDeleteAliasParams, callback: (error: any, response: any, status: any) => void): void;
|
|
deleteAlias(params: IndicesDeleteAliasParams): Promise<any>;
|
|
deleteTemplate(params: IndicesDeleteTemplateParams, callback: (error: any, response: any, status: any) => void): void;
|
|
deleteTemplate(params: IndicesDeleteTemplateParams): Promise<any>;
|
|
exists(params: IndicesExistsParams, callback: (error: any, response: boolean, status: any) => void): void;
|
|
exists(params: IndicesExistsParams): Promise<boolean>;
|
|
existsAlias(params: IndicesExistsAliasParams, callback: (error: any, response: boolean, status: any) => void): void;
|
|
existsAlias(params: IndicesExistsAliasParams): Promise<boolean>;
|
|
existsTemplate(params: IndicesExistsTemplateParams, callback: (error: any, response: boolean, status: any) => void): void;
|
|
existsTemplate(params: IndicesExistsTemplateParams): Promise<boolean>;
|
|
existsType(params: IndicesExistsTypeParams, callback: (error: any, response: boolean, status: any) => void): void;
|
|
existsType(params: IndicesExistsTypeParams): Promise<boolean>;
|
|
flush(params: IndicesFlushParams, callback: (error: any, response: any, status: any) => void): void;
|
|
flush(params: IndicesFlushParams): Promise<any>;
|
|
flushSynced(params: IndicesFlushSyncedParams, callback: (error: any, response: any, status: any) => void): void;
|
|
flushSynced(params: IndicesFlushSyncedParams): Promise<any>;
|
|
forcemerge(params: IndicesForcemergeParams, callback: (error: any, response: any, status: any) => void): void;
|
|
forcemerge(params: IndicesForcemergeParams): Promise<any>;
|
|
get(params: IndicesGetParams, callback: (error: any, response: any, status: any) => void): void;
|
|
get(params: IndicesGetParams): Promise<any>;
|
|
getAlias(params: IndicesGetAliasParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getAlias(params: IndicesGetAliasParams): Promise<any>;
|
|
getFieldMapping(params: IndicesGetFieldMappingParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getFieldMapping(params: IndicesGetFieldMappingParams): Promise<any>;
|
|
getMapping(params: IndicesGetMappingParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getMapping(params: IndicesGetMappingParams): Promise<any>;
|
|
getSettings(params: IndicesGetSettingsParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getSettings(params: IndicesGetSettingsParams): Promise<any>;
|
|
getTemplate(params: IndicesGetTemplateParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getTemplate(params: IndicesGetTemplateParams): Promise<any>;
|
|
getUpgrade(params: IndicesGetUpgradeParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getUpgrade(params: IndicesGetUpgradeParams): Promise<any>;
|
|
open(params: IndicesOpenParams, callback: (error: any, response: any, status: any) => void): void;
|
|
open(params: IndicesOpenParams): Promise<any>;
|
|
putAlias(params: IndicesPutAliasParams, callback: (error: any, response: any, status: any) => void): void;
|
|
putAlias(params: IndicesPutAliasParams): Promise<any>;
|
|
putMapping(params: IndicesPutMappingParams, callback: (error: any, response: any, status: any) => void): void;
|
|
putMapping(params: IndicesPutMappingParams): Promise<any>;
|
|
putSettings(params: IndicesPutSettingsParams, callback: (error: any, response: any, status: any) => void): void;
|
|
putSettings(params: IndicesPutSettingsParams): Promise<any>;
|
|
putTemplate(params: IndicesPutTemplateParams, callback: (error: any, response: any) => void): void;
|
|
putTemplate(params: IndicesPutTemplateParams): Promise<any>;
|
|
recovery(params: IndicesRecoveryParams, callback: (error: any, response: any) => void): void;
|
|
recovery(params: IndicesRecoveryParams): Promise<any>;
|
|
refresh(params: IndicesRefreshParams, callback: (error: any, response: any) => void): void;
|
|
refresh(params: IndicesRefreshParams): Promise<any>;
|
|
rollover(params: IndicesRolloverParams, callback: (error: any, response: IndicesRolloverResponse) => void): void;
|
|
rollover(params: IndicesRolloverParams): Promise<IndicesRolloverResponse>;
|
|
segments(params: IndicesSegmentsParams, callback: (error: any, response: any) => void): void;
|
|
segments(params: IndicesSegmentsParams): Promise<any>;
|
|
shardStores(params: IndicesShardStoresParams, callback: (error: any, response: any) => void): void;
|
|
shardStores(params: IndicesShardStoresParams): Promise<any>;
|
|
shrink(params: IndicesShrinkParams, callback: (error: any, response: any) => void): void;
|
|
shrink(params: IndicesShrinkParams): Promise<any>;
|
|
stats(params: IndicesStatsParams, callback: (error: any, response: any) => void): void;
|
|
stats(params: IndicesStatsParams): Promise<any>;
|
|
updateAliases(params: IndicesUpdateAliasesParams, callback: (error: any, response: any) => void): void;
|
|
updateAliases(params: IndicesUpdateAliasesParams): Promise<any>;
|
|
upgrade(params: IndicesUpgradeParams, callback: (error: any, response: any) => void): void;
|
|
upgrade(params: IndicesUpgradeParams): Promise<any>;
|
|
validateQuery(params: IndicesValidateQueryParams, callback: (error: any, response: any) => void): void;
|
|
validateQuery(params: IndicesValidateQueryParams): Promise<any>;
|
|
}
|
|
|
|
export interface IndicesAnalyzeParams extends GenericParams {
|
|
analyzer?: string;
|
|
charFilter?: NameList;
|
|
field?: string;
|
|
filter?: NameList;
|
|
index?: string;
|
|
perferLocal?: boolean;
|
|
text?: NameList;
|
|
tokenizer?: string;
|
|
explain?: boolean;
|
|
attributes?: NameList;
|
|
format?: "";
|
|
}
|
|
|
|
export interface IndicesClearCacheParams extends GenericParams {
|
|
fieldData?: boolean;
|
|
fielddata?: boolean; // yes the docs really have both
|
|
fields?: NameList;
|
|
query?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index?: NameList;
|
|
recycler?: boolean;
|
|
request?: boolean;
|
|
}
|
|
|
|
export interface IndicesCloseParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesCreateParams extends GenericParams {
|
|
waitForActiveShards?: string;
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
updateAllTypes?: boolean;
|
|
index: string;
|
|
}
|
|
|
|
export interface IndicesDeleteParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
index: NameList;
|
|
ignoreUnavailable?: boolean;
|
|
}
|
|
|
|
export interface IndicesDeleteAliasParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
index: NameList;
|
|
name: NameList;
|
|
}
|
|
|
|
export interface IndicesDeleteTemplateParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
name: string;
|
|
}
|
|
|
|
export interface IndicesExistsParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
local?: boolean;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesExistsAliasParams extends IndicesExistsParams {
|
|
name: NameList;
|
|
}
|
|
|
|
export interface IndicesExistsTemplateParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
name: NameList;
|
|
}
|
|
|
|
export interface IndicesExistsTypeParams extends IndicesExistsParams {
|
|
type: NameList;
|
|
}
|
|
|
|
export interface IndicesFlushParams extends GenericParams {
|
|
force?: boolean;
|
|
waitIfOngoing?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesFlushSyncedParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesForcemergeParams extends GenericParams {
|
|
flush?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
maxNumSegments?: number;
|
|
onlyExpungeDeletes?: boolean;
|
|
operationThreading?: any; // even the docs don't know what this does
|
|
waitForMerge?: boolean;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesGetParams extends GenericParams {
|
|
local?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
flatSettings?: boolean;
|
|
human?: boolean;
|
|
includeDefaults?: boolean;
|
|
index?: NameList;
|
|
feature?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetAliasParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
local?: boolean;
|
|
index?: NameList;
|
|
name?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetFieldMappingParams extends GenericParams {
|
|
includeDefaults?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
local?: boolean;
|
|
index?: NameList;
|
|
type?: NameList;
|
|
fields?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetMappingParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
local?: boolean;
|
|
index?: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetSettingsParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
flatSettings?: boolean;
|
|
local?: boolean;
|
|
human?: boolean;
|
|
includeDefaults?: boolean;
|
|
index?: NameList;
|
|
name?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetTemplateParams extends GenericParams {
|
|
flatSettings?: boolean;
|
|
masterTimeout?: TimeSpan;
|
|
local?: boolean;
|
|
name?: NameList;
|
|
}
|
|
|
|
export interface IndicesGetUpgradeParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
human?: boolean;
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface IndicesOpenParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
index?: NameList;
|
|
}
|
|
|
|
export interface IndicesPutAliasParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
index?: NameList;
|
|
name: NameList;
|
|
}
|
|
|
|
export interface IndicesPutMappingParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
updateAllTypes?: boolean;
|
|
index: NameList;
|
|
type: string;
|
|
body: any;
|
|
}
|
|
|
|
export interface IndicesPutSettingsParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
preserveExisting?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
flatSettings?: boolean;
|
|
index: NameList;
|
|
body: any;
|
|
}
|
|
|
|
export interface IndicesPutTemplateParams extends GenericParams {
|
|
order?: number;
|
|
create?: boolean;
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
flatSettings?: boolean;
|
|
name: string;
|
|
body: any;
|
|
}
|
|
|
|
export interface IndicesRecoveryParams extends GenericParams {
|
|
detailed?: boolean;
|
|
activeOnly?: boolean;
|
|
human?: boolean;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesRefreshParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
force?: boolean;
|
|
operationThreading?: any; // even the docs don't know what this does
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesRolloverParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
waitForActiveShards?: number | string;
|
|
alias?: string;
|
|
newIndex?: string;
|
|
}
|
|
|
|
export interface IndicesRolloverResponse {
|
|
acknowledged: boolean;
|
|
shards_acknowledged: boolean;
|
|
old_index: string;
|
|
new_index: string;
|
|
rolled_over: boolean;
|
|
dry_run: boolean;
|
|
conditions: { [condition: string]: boolean };
|
|
}
|
|
|
|
export interface IndicesSegmentsParams extends GenericParams {
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
human?: boolean;
|
|
operationThreading?: any; // even the docs don't know what this does
|
|
verbose?: boolean;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesShardStoresParams extends GenericParams {
|
|
status?: NameList;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
operationThreading?: any; // even the docs don't know what this does
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesShrinkParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
waitForActiveShards?: string | number;
|
|
index: string;
|
|
target: string;
|
|
}
|
|
|
|
export interface IndicesStatsParams extends GenericParams {
|
|
completionFields?: NameList;
|
|
fielddataFields?: NameList;
|
|
fields?: NameList;
|
|
groups?: NameList;
|
|
human?: boolean;
|
|
level?: "cluster" | "indices" | "shards";
|
|
types?: NameList;
|
|
index: NameList;
|
|
metric?: NameList;
|
|
}
|
|
|
|
export interface IndicesUpdateAliasesParams extends GenericParams {
|
|
timeout?: TimeSpan;
|
|
masterTimeout?: TimeSpan;
|
|
body: {
|
|
actions: IndicesUpdateAliasesParamsAction[];
|
|
};
|
|
}
|
|
|
|
export interface IndicesUpdateAliasesParamsAction {
|
|
add?: {
|
|
index?: string;
|
|
indices?: string[];
|
|
alias: string;
|
|
routing?: string;
|
|
filter?: object;
|
|
};
|
|
remove?: {
|
|
index?: string;
|
|
indices?: string[];
|
|
alias: string;
|
|
};
|
|
remove_index?: {
|
|
index: string;
|
|
};
|
|
}
|
|
|
|
export interface IndicesUpgradeParams extends GenericParams {
|
|
expandWildcards?: ExpandWildcards;
|
|
ignoreUnavailable?: boolean;
|
|
waitForCompletion?: boolean;
|
|
onlyAncientSegments?: boolean;
|
|
index: NameList;
|
|
}
|
|
|
|
export interface IndicesValidateQueryParams extends GenericParams {
|
|
explain?: boolean;
|
|
ignoreUnavailable?: boolean;
|
|
allowNoIndices?: boolean;
|
|
expandWildcards?: ExpandWildcards;
|
|
operationThreading?: any; // even the docs don't know what this does
|
|
q?: string;
|
|
analyzer?: string;
|
|
analyzeWildcard?: boolean;
|
|
defaultOperator?: DefaultOperator;
|
|
df?: string;
|
|
lenient?: boolean;
|
|
lowercaseExpandedTerms?: boolean;
|
|
rewrite?: boolean;
|
|
index: NameList;
|
|
type?: NameList;
|
|
}
|
|
|
|
export class Ingest {
|
|
deletePipeline(params: IngestDeletePipelineParams, callback: (error: any, response: any, status: any) => void): void;
|
|
deletePipeline(params: IngestDeletePipelineParams): Promise<any>;
|
|
getPipeline(params: IngestGetPipelineParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getPipeline(params: IngestGetPipelineParams): Promise<any>;
|
|
putPipeline(params: IngestPutPipelineParams, callback: (error: any, response: any, status: any) => void): void;
|
|
putPipeline(params: IngestPutPipelineParams): Promise<any>;
|
|
simulate(params: IngestSimulateParams, callback: (error: any, response: any, status: any) => void): void;
|
|
simulate(params: IngestSimulateParams): Promise<any>;
|
|
}
|
|
|
|
export interface IngestDeletePipelineParams extends GenericParams {
|
|
masterTimeout?: number;
|
|
timeout?: number;
|
|
id: string;
|
|
}
|
|
|
|
export interface IngestGetPipelineParams extends GenericParams {
|
|
masterTimeout?: number;
|
|
id: string;
|
|
}
|
|
|
|
export interface IngestPutPipelineParams extends GenericParams {
|
|
masterTimeout?: number;
|
|
timeout?: number;
|
|
id: string;
|
|
body: any;
|
|
}
|
|
|
|
export interface IngestSimulateParams extends GenericParams {
|
|
verbose?: boolean;
|
|
id: string;
|
|
}
|
|
|
|
export class Nodes {
|
|
hotThreads(params: NodesHotThreadsParams, callback: (error: any, response: any, status: any) => void): void;
|
|
hotThreads(params: NodesHotThreadsParams): Promise<any>;
|
|
info(params: NodesInfoParams, callback: (error: any, response: any, status: any) => void): void;
|
|
info(params: NodesInfoParams): Promise<any>;
|
|
stats(params: NodesStatsParams, callback: (error: any, response: any, status: any) => void): void;
|
|
stats(params: NodesStatsParams): Promise<any>;
|
|
}
|
|
|
|
export interface NodesHotThreadsParams extends GenericParams {
|
|
interval?: TimeSpan;
|
|
snapshots?: number;
|
|
threads?: number;
|
|
ignoreIdleThreads?: boolean;
|
|
type?: "cpu" | "wait" | "blocked";
|
|
timeout?: TimeSpan;
|
|
nodeId: NameList;
|
|
}
|
|
|
|
export interface NodesInfoParams extends GenericParams {
|
|
flatSettings?: boolean;
|
|
human?: boolean;
|
|
timeout?: TimeSpan;
|
|
nodeId: NameList;
|
|
metric?: NameList;
|
|
}
|
|
|
|
export interface NodesStatsParams extends GenericParams {
|
|
completionFields?: NameList;
|
|
fielddataFields?: NameList;
|
|
fields?: NameList;
|
|
groups?: boolean;
|
|
human?: boolean;
|
|
level?: "indices" | "node" | "shards";
|
|
types?: NameList;
|
|
timeout?: TimeSpan;
|
|
metric?: NameList;
|
|
indexMetric?: NameList;
|
|
nodeId?: NameList;
|
|
}
|
|
|
|
export class Snapshot {
|
|
create(params: SnapshotCreateParams, callback: (error: any, response: any, status: any) => void): void;
|
|
create(params: SnapshotCreateParams): Promise<any>;
|
|
createRepository(params: SnapshotCreateRepositoryParams, callback: (error: any, response: any, status: any) => void): void;
|
|
createRepository(params: SnapshotCreateRepositoryParams): Promise<any>;
|
|
delete(params: SnapshotDeleteParams, callback: (error: any, response: any, status: any) => void): void;
|
|
delete(params: SnapshotDeleteParams): Promise<any>;
|
|
deleteRepository(params: SnapshotDeleteRepositoryParams, callback: (error: any, response: any, status: any) => void): void;
|
|
deleteRepository(params: SnapshotDeleteRepositoryParams): Promise<any>;
|
|
get(params: SnapshotGetParams, callback: (error: any, response: any, status: any) => void): void;
|
|
get(params: SnapshotGetParams): Promise<any>;
|
|
getRepository(params: SnapshotGetRepositoryParams, callback: (error: any, response: any, status: any) => void): void;
|
|
getRepository(params: SnapshotGetRepositoryParams): Promise<any>;
|
|
restore(params: SnapshotRestoreParams, callback: (error: any, response: any, status: any) => void): void;
|
|
restore(params: SnapshotRestoreParams): Promise<any>;
|
|
status(params: SnapshotStatusParams, callback: (error: any, response: any, status: any) => void): void;
|
|
status(params: SnapshotStatusParams): Promise<any>;
|
|
verifyRepository(params: SnapshotVerifyRepositoryParams, callback: (error: any, response: any, status: any) => void): void;
|
|
verifyRepository(params: SnapshotVerifyRepositoryParams): Promise<any>;
|
|
}
|
|
|
|
export interface SnapshotCreateParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
waitForCompletion?: boolean;
|
|
repository: string;
|
|
snapshot: string;
|
|
}
|
|
|
|
export interface SnapshotCreateRepositoryParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
verify?: boolean;
|
|
repository: string;
|
|
}
|
|
|
|
export interface SnapshotDeleteParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
repository: string;
|
|
snapshot: string;
|
|
}
|
|
|
|
export interface SnapshotDeleteRepositoryParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
repository: string;
|
|
}
|
|
|
|
export interface SnapshotGetParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
ignoreUnavailable?: boolean;
|
|
repository: string;
|
|
snapshot: NameList;
|
|
}
|
|
|
|
export interface SnapshotGetRepositoryParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
local?: boolean;
|
|
repository: NameList;
|
|
}
|
|
|
|
export interface SnapshotRestoreParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
waitForCompletion?: boolean;
|
|
repository: string;
|
|
snapshot: string;
|
|
}
|
|
|
|
export interface SnapshotStatusParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
ignoreUnavailable?: boolean;
|
|
repository: string;
|
|
snapshot: NameList;
|
|
}
|
|
|
|
export interface SnapshotVerifyRepositoryParams extends GenericParams {
|
|
masterTimeout?: TimeSpan;
|
|
timeout?: TimeSpan;
|
|
repository: string;
|
|
}
|
|
|
|
export class Tasks {
|
|
cancel(params: TasksCancelParams, callback: (error: any, response: any, status: any) => void): void;
|
|
cancel(params: TasksCancelParams): Promise<any>;
|
|
get(params: TasksGetParams, callback: (error: any, response: any, status: any) => void): void;
|
|
get(params: TasksGetParams): Promise<any>;
|
|
list(params: TasksListParams, callback: (error: any, response: any, status: any) => void): void;
|
|
list(params: TasksListParams): Promise<any>;
|
|
}
|
|
|
|
export interface TasksCancelParams extends GenericParams {
|
|
nodeId?: NameList;
|
|
actions?: NameList;
|
|
parentNode?: string;
|
|
parentTask?: string;
|
|
taskId?: string;
|
|
}
|
|
|
|
export interface TasksGetParams extends GenericParams {
|
|
waitForCompletion?: boolean;
|
|
taskId?: string;
|
|
}
|
|
|
|
export interface TasksListParams extends GenericParams {
|
|
nodeId?: NameList;
|
|
actions?: NameList;
|
|
detailed?: boolean;
|
|
parentNode?: string;
|
|
parentTask?: string;
|
|
waitForCompletion?: boolean;
|
|
groupBy?: "nodes" | "parents";
|
|
}
|
|
|
|
export namespace errors {
|
|
class _Abstract extends Error {}
|
|
class Generic extends _Abstract {}
|
|
class ConnectionFault extends _Abstract {}
|
|
class NoConnections extends _Abstract {}
|
|
class Serialization extends _Abstract {}
|
|
class RequestTypeError extends _Abstract {}
|
|
|
|
class AuthenticationException extends _Abstract {}
|
|
class AuthorizationException extends _Abstract {}
|
|
class BadGateway extends _Abstract {}
|
|
class BadRequest extends _Abstract {}
|
|
class BlockedByWindowsParentalControls extends _Abstract {}
|
|
class ClientClosedRequest extends _Abstract {}
|
|
class Conflict extends _Abstract {}
|
|
class ExpectationFailed extends _Abstract {}
|
|
class Forbidden extends _Abstract {}
|
|
class GatewayTimeout extends _Abstract {}
|
|
class HTTPToHTTPS extends _Abstract {}
|
|
class HTTPVersionNotSupported extends _Abstract {}
|
|
class ImATeapot extends _Abstract {}
|
|
class InternalServerError extends _Abstract {}
|
|
class LengthRequired extends _Abstract {}
|
|
class MethodNotAllowed extends _Abstract {}
|
|
class MovedPermanently extends _Abstract {}
|
|
class MultipleChoices extends _Abstract {}
|
|
class NotAcceptable extends _Abstract {}
|
|
class NotExtended extends _Abstract {}
|
|
class NotFound extends _Abstract {}
|
|
class NotImplemented extends _Abstract {}
|
|
class NotModified extends _Abstract {}
|
|
class PaymentRequired extends _Abstract {}
|
|
class PermanentRedirect extends _Abstract {}
|
|
class PreconditionFailed extends _Abstract {}
|
|
class ProxyAuthenticationRequired extends _Abstract {}
|
|
class RequestedRangeNotSatisfiable extends _Abstract {}
|
|
class RequestEntityTooLarge extends _Abstract {}
|
|
class RequestHeaderTooLarge extends _Abstract {}
|
|
class RequestTimeout extends _Abstract {}
|
|
class RequestURITooLong extends _Abstract {}
|
|
class SeeOther extends _Abstract {}
|
|
class ServiceUnavailable extends _Abstract {}
|
|
class TemporaryRedirect extends _Abstract {}
|
|
class TooManyConnectionsFromThisIP extends _Abstract {}
|
|
class TooManyRequests extends _Abstract {}
|
|
class UnsupportedMediaType extends _Abstract {}
|
|
class UpgradeRequired extends _Abstract {}
|
|
class UseProxy extends _Abstract {}
|
|
class VariantAlsoNegotiates extends _Abstract {}
|
|
}
|