@elastic/elasticsearch
Version:
The official Elasticsearch client for Node.js
1,590 lines • 612 kB
TypeScript
/**
* We are still working on this type, it will arrive soon.
* If it's critical for you, please open an issue.
* https://github.com/elastic/elasticsearch-js
*/
export type TODO = Record<string, any>;
export interface BulkCreateOperation extends BulkWriteOperation {
}
export interface BulkDeleteOperation extends BulkOperationBase {
}
export type BulkFailureStoreStatus = 'not_applicable_or_unknown' | 'used' | 'not_enabled' | 'failed';
export interface BulkIndexOperation extends BulkWriteOperation {
}
export interface BulkOperationBase {
_id?: Id;
_index?: IndexName;
routing?: Routing;
if_primary_term?: long;
if_seq_no?: SequenceNumber;
version?: VersionNumber;
version_type?: VersionType;
}
export interface BulkOperationContainer {
index?: BulkIndexOperation;
create?: BulkCreateOperation;
update?: BulkUpdateOperation;
delete?: BulkDeleteOperation;
}
export type BulkOperationType = 'index' | 'create' | 'update' | 'delete';
export interface BulkRequest<TDocument = unknown, TPartialDocument = unknown> extends RequestBase {
index?: IndexName;
list_executed_pipelines?: boolean;
pipeline?: string;
refresh?: Refresh;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
timeout?: Duration;
wait_for_active_shards?: WaitForActiveShards;
require_alias?: boolean;
require_data_stream?: boolean;
operations?: (BulkOperationContainer | BulkUpdateAction<TDocument, TPartialDocument> | TDocument)[];
}
export interface BulkResponse {
errors: boolean;
items: Partial<Record<BulkOperationType, BulkResponseItem>>[];
took: long;
ingest_took?: long;
}
export interface BulkResponseItem {
_id?: string | null;
_index: string;
status: integer;
failure_store?: BulkFailureStoreStatus;
error?: ErrorCause;
_primary_term?: long;
result?: string;
_seq_no?: SequenceNumber;
_shards?: ShardStatistics;
_version?: VersionNumber;
forced_refresh?: boolean;
get?: InlineGet<Record<string, any>>;
}
export interface BulkUpdateAction<TDocument = unknown, TPartialDocument = unknown> {
detect_noop?: boolean;
doc?: TPartialDocument;
doc_as_upsert?: boolean;
script?: Script | string;
scripted_upsert?: boolean;
_source?: SearchSourceConfig;
upsert?: TDocument;
}
export interface BulkUpdateOperation extends BulkOperationBase {
require_alias?: boolean;
retry_on_conflict?: integer;
}
export interface BulkWriteOperation extends BulkOperationBase {
dynamic_templates?: Record<string, string>;
pipeline?: string;
require_alias?: boolean;
}
export interface ClearScrollRequest extends RequestBase {
scroll_id?: ScrollIds;
}
export interface ClearScrollResponse {
succeeded: boolean;
num_freed: integer;
}
export interface ClosePointInTimeRequest extends RequestBase {
id: Id;
}
export interface ClosePointInTimeResponse {
succeeded: boolean;
num_freed: integer;
}
export interface CountRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
analyzer?: string;
analyze_wildcard?: boolean;
default_operator?: QueryDslOperator;
df?: string;
expand_wildcards?: ExpandWildcards;
ignore_throttled?: boolean;
ignore_unavailable?: boolean;
lenient?: boolean;
min_score?: double;
preference?: string;
routing?: Routing;
terminate_after?: long;
q?: string;
query?: QueryDslQueryContainer;
}
export interface CountResponse {
count: long;
_shards: ShardStatistics;
}
export interface CreateRequest<TDocument = unknown> extends RequestBase {
id: Id;
index: IndexName;
pipeline?: string;
refresh?: Refresh;
routing?: Routing;
timeout?: Duration;
version?: VersionNumber;
version_type?: VersionType;
wait_for_active_shards?: WaitForActiveShards;
document?: TDocument;
}
export type CreateResponse = WriteResponseBase;
export interface DeleteRequest extends RequestBase {
id: Id;
index: IndexName;
if_primary_term?: long;
if_seq_no?: SequenceNumber;
refresh?: Refresh;
routing?: Routing;
timeout?: Duration;
version?: VersionNumber;
version_type?: VersionType;
wait_for_active_shards?: WaitForActiveShards;
}
export type DeleteResponse = WriteResponseBase;
export interface DeleteByQueryRequest extends RequestBase {
index: Indices;
allow_no_indices?: boolean;
analyzer?: string;
analyze_wildcard?: boolean;
conflicts?: Conflicts;
default_operator?: QueryDslOperator;
df?: string;
expand_wildcards?: ExpandWildcards;
from?: long;
ignore_unavailable?: boolean;
lenient?: boolean;
preference?: string;
refresh?: boolean;
request_cache?: boolean;
requests_per_second?: float;
routing?: Routing;
q?: string;
scroll?: Duration;
scroll_size?: long;
search_timeout?: Duration;
search_type?: SearchType;
slices?: Slices;
sort?: string[];
stats?: string[];
terminate_after?: long;
timeout?: Duration;
version?: boolean;
wait_for_active_shards?: WaitForActiveShards;
wait_for_completion?: boolean;
max_docs?: long;
query?: QueryDslQueryContainer;
slice?: SlicedScroll;
}
export interface DeleteByQueryResponse {
batches?: long;
deleted?: long;
failures?: BulkIndexByScrollFailure[];
noops?: long;
requests_per_second?: float;
retries?: Retries;
slice_id?: integer;
task?: TaskId;
throttled?: Duration;
throttled_millis?: DurationValue<UnitMillis>;
throttled_until?: Duration;
throttled_until_millis?: DurationValue<UnitMillis>;
timed_out?: boolean;
took?: DurationValue<UnitMillis>;
total?: long;
version_conflicts?: long;
}
export interface DeleteByQueryRethrottleRequest extends RequestBase {
task_id: TaskId;
requests_per_second?: float;
}
export type DeleteByQueryRethrottleResponse = TasksTaskListResponseBase;
export interface DeleteScriptRequest extends RequestBase {
id: Id;
master_timeout?: Duration;
timeout?: Duration;
}
export type DeleteScriptResponse = AcknowledgedResponseBase;
export interface ExistsRequest extends RequestBase {
id: Id;
index: IndexName;
preference?: string;
realtime?: boolean;
refresh?: boolean;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
stored_fields?: Fields;
version?: VersionNumber;
version_type?: VersionType;
}
export type ExistsResponse = boolean;
export interface ExistsSourceRequest extends RequestBase {
id: Id;
index: IndexName;
preference?: string;
realtime?: boolean;
refresh?: boolean;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
version?: VersionNumber;
version_type?: VersionType;
}
export type ExistsSourceResponse = boolean;
export interface ExplainExplanation {
description: string;
details: ExplainExplanationDetail[];
value: float;
}
export interface ExplainExplanationDetail {
description: string;
details?: ExplainExplanationDetail[];
value: float;
}
export interface ExplainRequest extends RequestBase {
id: Id;
index: IndexName;
analyzer?: string;
analyze_wildcard?: boolean;
default_operator?: QueryDslOperator;
df?: string;
lenient?: boolean;
preference?: string;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
stored_fields?: Fields;
q?: string;
query?: QueryDslQueryContainer;
}
export interface ExplainResponse<TDocument = unknown> {
_index: IndexName;
_id: Id;
matched: boolean;
explanation?: ExplainExplanationDetail;
get?: InlineGet<TDocument>;
}
export interface FieldCapsFieldCapability {
aggregatable: boolean;
indices?: Indices;
meta?: Metadata;
non_aggregatable_indices?: Indices;
non_searchable_indices?: Indices;
searchable: boolean;
type: string;
metadata_field?: boolean;
time_series_dimension?: boolean;
time_series_metric?: MappingTimeSeriesMetricType;
non_dimension_indices?: IndexName[];
metric_conflicts_indices?: IndexName[];
}
export interface FieldCapsRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
expand_wildcards?: ExpandWildcards;
ignore_unavailable?: boolean;
include_unmapped?: boolean;
filters?: string;
types?: string[];
include_empty_fields?: boolean;
fields?: Fields;
index_filter?: QueryDslQueryContainer;
runtime_mappings?: MappingRuntimeFields;
}
export interface FieldCapsResponse {
indices: Indices;
fields: Record<Field, Record<string, FieldCapsFieldCapability>>;
}
export interface GetGetResult<TDocument = unknown> {
_index: IndexName;
fields?: Record<string, any>;
_ignored?: string[];
found: boolean;
_id: Id;
_primary_term?: long;
_routing?: string;
_seq_no?: SequenceNumber;
_source?: TDocument;
_version?: VersionNumber;
}
export interface GetRequest extends RequestBase {
id: Id;
index: IndexName;
force_synthetic_source?: boolean;
preference?: string;
realtime?: boolean;
refresh?: boolean;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
stored_fields?: Fields;
version?: VersionNumber;
version_type?: VersionType;
}
export type GetResponse<TDocument = unknown> = GetGetResult<TDocument>;
export interface GetScriptRequest extends RequestBase {
id: Id;
master_timeout?: Duration;
}
export interface GetScriptResponse {
_id: Id;
found: boolean;
script?: StoredScript;
}
export interface GetScriptContextContext {
methods: GetScriptContextContextMethod[];
name: Name;
}
export interface GetScriptContextContextMethod {
name: Name;
return_type: string;
params: GetScriptContextContextMethodParam[];
}
export interface GetScriptContextContextMethodParam {
name: Name;
type: string;
}
export interface GetScriptContextRequest extends RequestBase {
}
export interface GetScriptContextResponse {
contexts: GetScriptContextContext[];
}
export interface GetScriptLanguagesLanguageContext {
contexts: string[];
language: ScriptLanguage;
}
export interface GetScriptLanguagesRequest extends RequestBase {
}
export interface GetScriptLanguagesResponse {
language_contexts: GetScriptLanguagesLanguageContext[];
types_allowed: string[];
}
export interface GetSourceRequest extends RequestBase {
id: Id;
index: IndexName;
preference?: string;
realtime?: boolean;
refresh?: boolean;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
stored_fields?: Fields;
version?: VersionNumber;
version_type?: VersionType;
}
export type GetSourceResponse<TDocument = unknown> = TDocument;
export interface HealthReportBaseIndicator {
status: HealthReportIndicatorHealthStatus;
symptom: string;
impacts?: HealthReportImpact[];
diagnosis?: HealthReportDiagnosis[];
}
export interface HealthReportDataStreamLifecycleDetails {
stagnating_backing_indices_count: integer;
total_backing_indices_in_error: integer;
stagnating_backing_indices?: HealthReportStagnatingBackingIndices[];
}
export interface HealthReportDataStreamLifecycleIndicator extends HealthReportBaseIndicator {
details?: HealthReportDataStreamLifecycleDetails;
}
export interface HealthReportDiagnosis {
id: string;
action: string;
affected_resources: HealthReportDiagnosisAffectedResources;
cause: string;
help_url: string;
}
export interface HealthReportDiagnosisAffectedResources {
indices?: Indices;
nodes?: HealthReportIndicatorNode[];
slm_policies?: string[];
feature_states?: string[];
snapshot_repositories?: string[];
}
export interface HealthReportDiskIndicator extends HealthReportBaseIndicator {
details?: HealthReportDiskIndicatorDetails;
}
export interface HealthReportDiskIndicatorDetails {
indices_with_readonly_block: long;
nodes_with_enough_disk_space: long;
nodes_over_high_watermark: long;
nodes_over_flood_stage_watermark: long;
nodes_with_unknown_disk_status: long;
}
export interface HealthReportIlmIndicator extends HealthReportBaseIndicator {
details?: HealthReportIlmIndicatorDetails;
}
export interface HealthReportIlmIndicatorDetails {
ilm_status: LifecycleOperationMode;
policies: long;
stagnating_indices: integer;
}
export interface HealthReportImpact {
description: string;
id: string;
impact_areas: HealthReportImpactArea[];
severity: integer;
}
export type HealthReportImpactArea = 'search' | 'ingest' | 'backup' | 'deployment_management';
export type HealthReportIndicatorHealthStatus = 'green' | 'yellow' | 'red' | 'unknown';
export interface HealthReportIndicatorNode {
name: string | null;
node_id: string | null;
}
export interface HealthReportIndicators {
master_is_stable?: HealthReportMasterIsStableIndicator;
shards_availability?: HealthReportShardsAvailabilityIndicator;
disk?: HealthReportDiskIndicator;
repository_integrity?: HealthReportRepositoryIntegrityIndicator;
data_stream_lifecycle?: HealthReportDataStreamLifecycleIndicator;
ilm?: HealthReportIlmIndicator;
slm?: HealthReportSlmIndicator;
shards_capacity?: HealthReportShardsCapacityIndicator;
}
export interface HealthReportMasterIsStableIndicator extends HealthReportBaseIndicator {
details?: HealthReportMasterIsStableIndicatorDetails;
}
export interface HealthReportMasterIsStableIndicatorClusterFormationNode {
name?: string;
node_id: string;
cluster_formation_message: string;
}
export interface HealthReportMasterIsStableIndicatorDetails {
current_master: HealthReportIndicatorNode;
recent_masters: HealthReportIndicatorNode[];
exception_fetching_history?: HealthReportMasterIsStableIndicatorExceptionFetchingHistory;
cluster_formation?: HealthReportMasterIsStableIndicatorClusterFormationNode[];
}
export interface HealthReportMasterIsStableIndicatorExceptionFetchingHistory {
message: string;
stack_trace: string;
}
export interface HealthReportRepositoryIntegrityIndicator extends HealthReportBaseIndicator {
details?: HealthReportRepositoryIntegrityIndicatorDetails;
}
export interface HealthReportRepositoryIntegrityIndicatorDetails {
total_repositories?: long;
corrupted_repositories?: long;
corrupted?: string[];
}
export interface HealthReportRequest extends RequestBase {
feature?: string | string[];
timeout?: Duration;
verbose?: boolean;
size?: integer;
}
export interface HealthReportResponse {
cluster_name: string;
indicators: HealthReportIndicators;
status?: HealthReportIndicatorHealthStatus;
}
export interface HealthReportShardsAvailabilityIndicator extends HealthReportBaseIndicator {
details?: HealthReportShardsAvailabilityIndicatorDetails;
}
export interface HealthReportShardsAvailabilityIndicatorDetails {
creating_primaries: long;
creating_replicas: long;
initializing_primaries: long;
initializing_replicas: long;
restarting_primaries: long;
restarting_replicas: long;
started_primaries: long;
started_replicas: long;
unassigned_primaries: long;
unassigned_replicas: long;
}
export interface HealthReportShardsCapacityIndicator extends HealthReportBaseIndicator {
details?: HealthReportShardsCapacityIndicatorDetails;
}
export interface HealthReportShardsCapacityIndicatorDetails {
data: HealthReportShardsCapacityIndicatorTierDetail;
frozen: HealthReportShardsCapacityIndicatorTierDetail;
}
export interface HealthReportShardsCapacityIndicatorTierDetail {
max_shards_in_cluster: integer;
current_used_shards?: integer;
}
export interface HealthReportSlmIndicator extends HealthReportBaseIndicator {
details?: HealthReportSlmIndicatorDetails;
}
export interface HealthReportSlmIndicatorDetails {
slm_status: LifecycleOperationMode;
policies: long;
unhealthy_policies?: HealthReportSlmIndicatorUnhealthyPolicies;
}
export interface HealthReportSlmIndicatorUnhealthyPolicies {
count: long;
invocations_since_last_success?: Record<string, long>;
}
export interface HealthReportStagnatingBackingIndices {
index_name: IndexName;
first_occurrence_timestamp: long;
retry_count: integer;
}
export interface IndexRequest<TDocument = unknown> extends RequestBase {
id?: Id;
index: IndexName;
if_primary_term?: long;
if_seq_no?: SequenceNumber;
op_type?: OpType;
pipeline?: string;
refresh?: Refresh;
routing?: Routing;
timeout?: Duration;
version?: VersionNumber;
version_type?: VersionType;
wait_for_active_shards?: WaitForActiveShards;
require_alias?: boolean;
document?: TDocument;
}
export type IndexResponse = WriteResponseBase;
export interface InfoRequest extends RequestBase {
}
export interface InfoResponse {
cluster_name: Name;
cluster_uuid: Uuid;
name: Name;
tagline: string;
version: ElasticsearchVersionInfo;
}
export interface KnnSearchRequest extends RequestBase {
index: Indices;
routing?: Routing;
_source?: SearchSourceConfig;
docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
stored_fields?: Fields;
fields?: Fields;
filter?: QueryDslQueryContainer | QueryDslQueryContainer[];
knn: KnnSearchQuery;
}
export interface KnnSearchResponse<TDocument = unknown> {
took: long;
timed_out: boolean;
_shards: ShardStatistics;
hits: SearchHitsMetadata<TDocument>;
fields?: Record<string, any>;
max_score?: double;
}
export interface KnnSearchQuery {
field: Field;
query_vector: QueryVector;
k: integer;
num_candidates: integer;
}
export interface MgetMultiGetError {
error: ErrorCause;
_id: Id;
_index: IndexName;
}
export interface MgetOperation {
_id: Id;
_index?: IndexName;
routing?: Routing;
_source?: SearchSourceConfig;
stored_fields?: Fields;
version?: VersionNumber;
version_type?: VersionType;
}
export interface MgetRequest extends RequestBase {
index?: IndexName;
force_synthetic_source?: boolean;
preference?: string;
realtime?: boolean;
refresh?: boolean;
routing?: Routing;
_source?: SearchSourceConfigParam;
_source_excludes?: Fields;
_source_includes?: Fields;
stored_fields?: Fields;
docs?: MgetOperation[];
ids?: Ids;
}
export interface MgetResponse<TDocument = unknown> {
docs: MgetResponseItem<TDocument>[];
}
export type MgetResponseItem<TDocument = unknown> = GetGetResult<TDocument> | MgetMultiGetError;
export interface MsearchMultiSearchItem<TDocument = unknown> extends SearchResponseBody<TDocument> {
status?: integer;
}
export interface MsearchMultiSearchResult<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> {
took: long;
responses: MsearchResponseItem<TDocument>[];
}
export interface MsearchMultisearchBody {
aggregations?: Record<string, AggregationsAggregationContainer>;
aggs?: Record<string, AggregationsAggregationContainer>;
collapse?: SearchFieldCollapse;
query?: QueryDslQueryContainer;
explain?: boolean;
ext?: Record<string, any>;
stored_fields?: Fields;
docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
knn?: KnnSearch | KnnSearch[];
from?: integer;
highlight?: SearchHighlight;
indices_boost?: Record<IndexName, double>[];
min_score?: double;
post_filter?: QueryDslQueryContainer;
profile?: boolean;
rescore?: SearchRescore | SearchRescore[];
script_fields?: Record<string, ScriptField>;
search_after?: SortResults;
size?: integer;
sort?: Sort;
_source?: SearchSourceConfig;
fields?: (QueryDslFieldAndFormat | Field)[];
terminate_after?: long;
stats?: string[];
timeout?: string;
track_scores?: boolean;
track_total_hits?: SearchTrackHits;
version?: boolean;
runtime_mappings?: MappingRuntimeFields;
seq_no_primary_term?: boolean;
pit?: SearchPointInTimeReference;
suggest?: SearchSuggester;
}
export interface MsearchMultisearchHeader {
allow_no_indices?: boolean;
expand_wildcards?: ExpandWildcards;
ignore_unavailable?: boolean;
index?: Indices;
preference?: string;
request_cache?: boolean;
routing?: Routing;
search_type?: SearchType;
ccs_minimize_roundtrips?: boolean;
allow_partial_search_results?: boolean;
ignore_throttled?: boolean;
}
export interface MsearchRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
ccs_minimize_roundtrips?: boolean;
expand_wildcards?: ExpandWildcards;
ignore_throttled?: boolean;
ignore_unavailable?: boolean;
include_named_queries_score?: boolean;
max_concurrent_searches?: long;
max_concurrent_shard_requests?: long;
pre_filter_shard_size?: long;
rest_total_hits_as_int?: boolean;
routing?: Routing;
search_type?: SearchType;
typed_keys?: boolean;
searches?: MsearchRequestItem[];
}
export type MsearchRequestItem = MsearchMultisearchHeader | MsearchMultisearchBody;
export type MsearchResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = MsearchMultiSearchResult<TDocument, TAggregations>;
export type MsearchResponseItem<TDocument = unknown> = MsearchMultiSearchItem<TDocument> | ErrorResponseBase;
export interface MsearchTemplateRequest extends RequestBase {
index?: Indices;
ccs_minimize_roundtrips?: boolean;
max_concurrent_searches?: long;
search_type?: SearchType;
rest_total_hits_as_int?: boolean;
typed_keys?: boolean;
search_templates?: MsearchTemplateRequestItem[];
}
export type MsearchTemplateRequestItem = MsearchMultisearchHeader | MsearchTemplateTemplateConfig;
export type MsearchTemplateResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = MsearchMultiSearchResult<TDocument, TAggregations>;
export interface MsearchTemplateTemplateConfig {
explain?: boolean;
id?: Id;
params?: Record<string, any>;
profile?: boolean;
source?: string;
}
export interface MtermvectorsOperation {
_id?: Id;
_index?: IndexName;
doc?: any;
fields?: Fields;
field_statistics?: boolean;
filter?: TermvectorsFilter;
offsets?: boolean;
payloads?: boolean;
positions?: boolean;
routing?: Routing;
term_statistics?: boolean;
version?: VersionNumber;
version_type?: VersionType;
}
export interface MtermvectorsRequest extends RequestBase {
index?: IndexName;
fields?: Fields;
field_statistics?: boolean;
offsets?: boolean;
payloads?: boolean;
positions?: boolean;
preference?: string;
realtime?: boolean;
routing?: Routing;
term_statistics?: boolean;
version?: VersionNumber;
version_type?: VersionType;
docs?: MtermvectorsOperation[];
ids?: Id[];
}
export interface MtermvectorsResponse {
docs: MtermvectorsTermVectorsResult[];
}
export interface MtermvectorsTermVectorsResult {
_id?: Id;
_index: IndexName;
_version?: VersionNumber;
took?: long;
found?: boolean;
term_vectors?: Record<Field, TermvectorsTermVector>;
error?: ErrorCause;
}
export interface OpenPointInTimeRequest extends RequestBase {
index: Indices;
keep_alive: Duration;
ignore_unavailable?: boolean;
preference?: string;
routing?: Routing;
expand_wildcards?: ExpandWildcards;
allow_partial_search_results?: boolean;
index_filter?: QueryDslQueryContainer;
}
export interface OpenPointInTimeResponse {
_shards: ShardStatistics;
id: Id;
}
export interface PingRequest extends RequestBase {
}
export type PingResponse = boolean;
export interface PutScriptRequest extends RequestBase {
id: Id;
context?: Name;
master_timeout?: Duration;
timeout?: Duration;
script: StoredScript;
}
export type PutScriptResponse = AcknowledgedResponseBase;
export interface RankEvalDocumentRating {
_id: Id;
_index: IndexName;
rating: integer;
}
export interface RankEvalRankEvalHit {
_id: Id;
_index: IndexName;
_score: double;
}
export interface RankEvalRankEvalHitItem {
hit: RankEvalRankEvalHit;
rating?: double | null;
}
export interface RankEvalRankEvalMetric {
precision?: RankEvalRankEvalMetricPrecision;
recall?: RankEvalRankEvalMetricRecall;
mean_reciprocal_rank?: RankEvalRankEvalMetricMeanReciprocalRank;
dcg?: RankEvalRankEvalMetricDiscountedCumulativeGain;
expected_reciprocal_rank?: RankEvalRankEvalMetricExpectedReciprocalRank;
}
export interface RankEvalRankEvalMetricBase {
k?: integer;
}
export interface RankEvalRankEvalMetricDetail {
metric_score: double;
unrated_docs: RankEvalUnratedDocument[];
hits: RankEvalRankEvalHitItem[];
metric_details: Record<string, Record<string, any>>;
}
export interface RankEvalRankEvalMetricDiscountedCumulativeGain extends RankEvalRankEvalMetricBase {
normalize?: boolean;
}
export interface RankEvalRankEvalMetricExpectedReciprocalRank extends RankEvalRankEvalMetricBase {
maximum_relevance: integer;
}
export interface RankEvalRankEvalMetricMeanReciprocalRank extends RankEvalRankEvalMetricRatingTreshold {
}
export interface RankEvalRankEvalMetricPrecision extends RankEvalRankEvalMetricRatingTreshold {
ignore_unlabeled?: boolean;
}
export interface RankEvalRankEvalMetricRatingTreshold extends RankEvalRankEvalMetricBase {
relevant_rating_threshold?: integer;
}
export interface RankEvalRankEvalMetricRecall extends RankEvalRankEvalMetricRatingTreshold {
}
export interface RankEvalRankEvalQuery {
query: QueryDslQueryContainer;
size?: integer;
}
export interface RankEvalRankEvalRequestItem {
id: Id;
request?: RankEvalRankEvalQuery | QueryDslQueryContainer;
ratings: RankEvalDocumentRating[];
template_id?: Id;
params?: Record<string, any>;
}
export interface RankEvalRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
expand_wildcards?: ExpandWildcards;
ignore_unavailable?: boolean;
search_type?: string;
requests: RankEvalRankEvalRequestItem[];
metric?: RankEvalRankEvalMetric;
}
export interface RankEvalResponse {
metric_score: double;
details: Record<Id, RankEvalRankEvalMetricDetail>;
failures: Record<string, any>;
}
export interface RankEvalUnratedDocument {
_id: Id;
_index: IndexName;
}
export interface ReindexDestination {
index: IndexName;
op_type?: OpType;
pipeline?: string;
routing?: Routing;
version_type?: VersionType;
}
export interface ReindexRemoteSource {
connect_timeout?: Duration;
headers?: Record<string, string>;
host: Host;
username?: Username;
password?: Password;
socket_timeout?: Duration;
}
export interface ReindexRequest extends RequestBase {
refresh?: boolean;
requests_per_second?: float;
scroll?: Duration;
slices?: Slices;
timeout?: Duration;
wait_for_active_shards?: WaitForActiveShards;
wait_for_completion?: boolean;
require_alias?: boolean;
conflicts?: Conflicts;
dest: ReindexDestination;
max_docs?: long;
script?: Script | string;
size?: long;
source: ReindexSource;
}
export interface ReindexResponse {
batches?: long;
created?: long;
deleted?: long;
failures?: BulkIndexByScrollFailure[];
noops?: long;
retries?: Retries;
requests_per_second?: float;
slice_id?: integer;
task?: TaskId;
throttled_millis?: EpochTime<UnitMillis>;
throttled_until_millis?: EpochTime<UnitMillis>;
timed_out?: boolean;
took?: DurationValue<UnitMillis>;
total?: long;
updated?: long;
version_conflicts?: long;
}
export interface ReindexSource {
index: Indices;
query?: QueryDslQueryContainer;
remote?: ReindexRemoteSource;
size?: integer;
slice?: SlicedScroll;
sort?: Sort;
_source?: Fields;
runtime_mappings?: MappingRuntimeFields;
}
export interface ReindexRethrottleReindexNode extends SpecUtilsBaseNode {
tasks: Record<TaskId, ReindexRethrottleReindexTask>;
}
export interface ReindexRethrottleReindexStatus {
batches: long;
created: long;
deleted: long;
noops: long;
requests_per_second: float;
retries: Retries;
throttled?: Duration;
throttled_millis: DurationValue<UnitMillis>;
throttled_until?: Duration;
throttled_until_millis: DurationValue<UnitMillis>;
total: long;
updated: long;
version_conflicts: long;
}
export interface ReindexRethrottleReindexTask {
action: string;
cancellable: boolean;
description: string;
id: long;
node: Name;
running_time_in_nanos: DurationValue<UnitNanos>;
start_time_in_millis: EpochTime<UnitMillis>;
status: ReindexRethrottleReindexStatus;
type: string;
headers: HttpHeaders;
}
export interface ReindexRethrottleRequest extends RequestBase {
task_id: Id;
requests_per_second?: float;
}
export interface ReindexRethrottleResponse {
nodes: Record<string, ReindexRethrottleReindexNode>;
}
export interface RenderSearchTemplateRequest extends RequestBase {
id?: Id;
file?: string;
params?: Record<string, any>;
source?: string;
}
export interface RenderSearchTemplateResponse {
template_output: Record<string, any>;
}
export interface ScriptsPainlessExecutePainlessContextSetup {
document: any;
index: IndexName;
query?: QueryDslQueryContainer;
}
export interface ScriptsPainlessExecuteRequest extends RequestBase {
context?: string;
context_setup?: ScriptsPainlessExecutePainlessContextSetup;
script?: Script | string;
}
export interface ScriptsPainlessExecuteResponse<TResult = unknown> {
result: TResult;
}
export interface ScrollRequest extends RequestBase {
scroll_id?: ScrollId;
rest_total_hits_as_int?: boolean;
scroll?: Duration;
}
export type ScrollResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = SearchResponseBody<TDocument, TAggregations>;
export interface SearchRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
allow_partial_search_results?: boolean;
analyzer?: string;
analyze_wildcard?: boolean;
batched_reduce_size?: long;
ccs_minimize_roundtrips?: boolean;
default_operator?: QueryDslOperator;
df?: string;
expand_wildcards?: ExpandWildcards;
ignore_throttled?: boolean;
ignore_unavailable?: boolean;
include_named_queries_score?: boolean;
lenient?: boolean;
max_concurrent_shard_requests?: long;
min_compatible_shard_node?: VersionString;
preference?: string;
pre_filter_shard_size?: long;
request_cache?: boolean;
routing?: Routing;
scroll?: Duration;
search_type?: SearchType;
suggest_field?: Field;
suggest_mode?: SuggestMode;
suggest_size?: long;
suggest_text?: string;
typed_keys?: boolean;
rest_total_hits_as_int?: boolean;
_source_excludes?: Fields;
_source_includes?: Fields;
q?: string;
force_synthetic_source?: boolean;
aggregations?: Record<string, AggregationsAggregationContainer>;
/** @alias aggregations */
aggs?: Record<string, AggregationsAggregationContainer>;
collapse?: SearchFieldCollapse;
explain?: boolean;
ext?: Record<string, any>;
from?: integer;
highlight?: SearchHighlight;
track_total_hits?: SearchTrackHits;
indices_boost?: Record<IndexName, double>[];
docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
knn?: KnnSearch | KnnSearch[];
rank?: RankContainer;
min_score?: double;
post_filter?: QueryDslQueryContainer;
profile?: boolean;
query?: QueryDslQueryContainer;
rescore?: SearchRescore | SearchRescore[];
retriever?: RetrieverContainer;
script_fields?: Record<string, ScriptField>;
search_after?: SortResults;
size?: integer;
slice?: SlicedScroll;
sort?: Sort;
_source?: SearchSourceConfig;
fields?: (QueryDslFieldAndFormat | Field)[];
suggest?: SearchSuggester;
terminate_after?: long;
timeout?: string;
track_scores?: boolean;
version?: boolean;
seq_no_primary_term?: boolean;
stored_fields?: Fields;
pit?: SearchPointInTimeReference;
runtime_mappings?: MappingRuntimeFields;
stats?: string[];
}
export type SearchResponse<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> = SearchResponseBody<TDocument, TAggregations>;
export interface SearchResponseBody<TDocument = unknown, TAggregations = Record<AggregateName, AggregationsAggregate>> {
took: long;
timed_out: boolean;
_shards: ShardStatistics;
hits: SearchHitsMetadata<TDocument>;
aggregations?: TAggregations;
_clusters?: ClusterStatistics;
fields?: Record<string, any>;
max_score?: double;
num_reduce_phases?: long;
profile?: SearchProfile;
pit_id?: Id;
_scroll_id?: ScrollId;
suggest?: Record<SuggestionName, SearchSuggest<TDocument>[]>;
terminated_early?: boolean;
}
export interface SearchAggregationBreakdown {
build_aggregation: long;
build_aggregation_count: long;
build_leaf_collector: long;
build_leaf_collector_count: long;
collect: long;
collect_count: long;
initialize: long;
initialize_count: long;
post_collection?: long;
post_collection_count?: long;
reduce: long;
reduce_count: long;
}
export interface SearchAggregationProfile {
breakdown: SearchAggregationBreakdown;
description: string;
time_in_nanos: DurationValue<UnitNanos>;
type: string;
debug?: SearchAggregationProfileDebug;
children?: SearchAggregationProfile[];
}
export interface SearchAggregationProfileDebug {
segments_with_multi_valued_ords?: integer;
collection_strategy?: string;
segments_with_single_valued_ords?: integer;
total_buckets?: integer;
built_buckets?: integer;
result_strategy?: string;
has_filter?: boolean;
delegate?: string;
delegate_debug?: SearchAggregationProfileDebug;
chars_fetched?: integer;
extract_count?: integer;
extract_ns?: integer;
values_fetched?: integer;
collect_analyzed_ns?: integer;
collect_analyzed_count?: integer;
surviving_buckets?: integer;
ordinals_collectors_used?: integer;
ordinals_collectors_overhead_too_high?: integer;
string_hashing_collectors_used?: integer;
numeric_collectors_used?: integer;
empty_collectors_used?: integer;
deferred_aggregators?: string[];
segments_with_doc_count_field?: integer;
segments_with_deleted_docs?: integer;
filters?: SearchAggregationProfileDelegateDebugFilter[];
segments_counted?: integer;
segments_collected?: integer;
map_reducer?: string;
brute_force_used?: integer;
dynamic_pruning_attempted?: integer;
dynamic_pruning_used?: integer;
skipped_due_to_no_data?: integer;
}
export interface SearchAggregationProfileDelegateDebugFilter {
results_from_metadata?: integer;
query?: string;
specialized_for?: string;
segments_counted_in_constant_time?: integer;
}
export type SearchBoundaryScanner = 'chars' | 'sentence' | 'word';
export interface SearchCollector {
name: string;
reason: string;
time_in_nanos: DurationValue<UnitNanos>;
children?: SearchCollector[];
}
export interface SearchCompletionContext {
boost?: double;
context: SearchContext;
neighbours?: GeoHashPrecision[];
precision?: GeoHashPrecision;
prefix?: boolean;
}
export interface SearchCompletionSuggest<TDocument = unknown> extends SearchSuggestBase {
options: SearchCompletionSuggestOption<TDocument> | SearchCompletionSuggestOption<TDocument>[];
}
export interface SearchCompletionSuggestOption<TDocument = unknown> {
collate_match?: boolean;
contexts?: Record<string, SearchContext[]>;
fields?: Record<string, any>;
_id?: string;
_index?: IndexName;
_routing?: Routing;
_score?: double;
_source?: TDocument;
text: string;
score?: double;
}
export interface SearchCompletionSuggester extends SearchSuggesterBase {
contexts?: Record<Field, SearchCompletionContext | SearchContext | (SearchCompletionContext | SearchContext)[]>;
fuzzy?: SearchSuggestFuzziness;
regex?: SearchRegexOptions;
skip_duplicates?: boolean;
}
export type SearchContext = string | GeoLocation;
export interface SearchDfsKnnProfile {
vector_operations_count?: long;
query: SearchKnnQueryProfileResult[];
rewrite_time: long;
collector: SearchKnnCollectorResult[];
}
export interface SearchDfsProfile {
statistics?: SearchDfsStatisticsProfile;
knn?: SearchDfsKnnProfile[];
}
export interface SearchDfsStatisticsBreakdown {
collection_statistics: long;
collection_statistics_count: long;
create_weight: long;
create_weight_count: long;
rewrite: long;
rewrite_count: long;
term_statistics: long;
term_statistics_count: long;
}
export interface SearchDfsStatisticsProfile {
type: string;
description: string;
time?: Duration;
time_in_nanos: DurationValue<UnitNanos>;
breakdown: SearchDfsStatisticsBreakdown;
debug?: Record<string, any>;
children?: SearchDfsStatisticsProfile[];
}
export interface SearchDirectGenerator {
field: Field;
max_edits?: integer;
max_inspections?: float;
max_term_freq?: float;
min_doc_freq?: float;
min_word_length?: integer;
post_filter?: string;
pre_filter?: string;
prefix_length?: integer;
size?: integer;
suggest_mode?: SuggestMode;
}
export interface SearchFetchProfile {
type: string;
description: string;
time_in_nanos: DurationValue<UnitNanos>;
breakdown: SearchFetchProfileBreakdown;
debug?: SearchFetchProfileDebug;
children?: SearchFetchProfile[];
}
export interface SearchFetchProfileBreakdown {
load_source?: integer;
load_source_count?: integer;
load_stored_fields?: integer;
load_stored_fields_count?: integer;
next_reader?: integer;
next_reader_count?: integer;
process_count?: integer;
process?: integer;
}
export interface SearchFetchProfileDebug {
stored_fields?: string[];
fast_path?: integer;
}
export interface SearchFieldCollapse {
field: Field;
inner_hits?: SearchInnerHits | SearchInnerHits[];
max_concurrent_group_searches?: integer;
collapse?: SearchFieldCollapse;
}
export interface SearchFieldSuggester {
completion?: SearchCompletionSuggester;
phrase?: SearchPhraseSuggester;
term?: SearchTermSuggester;
prefix?: string;
regex?: string;
text?: string;
}
export interface SearchHighlight extends SearchHighlightBase {
encoder?: SearchHighlighterEncoder;
fields: Record<Field, SearchHighlightField>;
}
export interface SearchHighlightBase {
type?: SearchHighlighterType;
boundary_chars?: string;
boundary_max_scan?: integer;
boundary_scanner?: SearchBoundaryScanner;
boundary_scanner_locale?: string;
force_source?: boolean;
fragmenter?: SearchHighlighterFragmenter;
fragment_size?: integer;
highlight_filter?: boolean;
highlight_query?: QueryDslQueryContainer;
max_fragment_length?: integer;
max_analyzed_offset?: integer;
no_match_size?: integer;
number_of_fragments?: integer;
options?: Record<string, any>;
order?: SearchHighlighterOrder;
phrase_limit?: integer;
post_tags?: string[];
pre_tags?: string[];
require_field_match?: boolean;
tags_schema?: SearchHighlighterTagsSchema;
}
export interface SearchHighlightField extends SearchHighlightBase {
fragment_offset?: integer;
matched_fields?: Fields;
}
export type SearchHighlighterEncoder = 'default' | 'html';
export type SearchHighlighterFragmenter = 'simple' | 'span';
export type SearchHighlighterOrder = 'score';
export type SearchHighlighterTagsSchema = 'styled';
export type SearchHighlighterType = 'plain' | 'fvh' | 'unified' | string;
export interface SearchHit<TDocument = unknown> {
_index: IndexName;
_id?: Id;
_score?: double | null;
_explanation?: ExplainExplanation;
fields?: Record<string, any>;
highlight?: Record<string, string[]>;
inner_hits?: Record<string, SearchInnerHitsResult>;
matched_queries?: string[] | Record<string, double>;
_nested?: SearchNestedIdentity;
_ignored?: string[];
ignored_field_values?: Record<string, FieldValue[]>;
_shard?: string;
_node?: string;
_routing?: string;
_source?: TDocument;
_rank?: integer;
_seq_no?: SequenceNumber;
_primary_term?: long;
_version?: VersionNumber;
sort?: SortResults;
}
export interface SearchHitsMetadata<T = unknown> {
total?: SearchTotalHits | long;
hits: SearchHit<T>[];
max_score?: double | null;
}
export interface SearchInnerHits {
name?: Name;
size?: integer;
from?: integer;
collapse?: SearchFieldCollapse;
docvalue_fields?: (QueryDslFieldAndFormat | Field)[];
explain?: boolean;
highlight?: SearchHighlight;
ignore_unmapped?: boolean;
script_fields?: Record<Field, ScriptField>;
seq_no_primary_term?: boolean;
fields?: Fields;
sort?: Sort;
_source?: SearchSourceConfig;
stored_fields?: Fields;
track_scores?: boolean;
version?: boolean;
}
export interface SearchInnerHitsResult {
hits: SearchHitsMetadata<any>;
}
export interface SearchKnnCollectorResult {
name: string;
reason: string;
time?: Duration;
time_in_nanos: DurationValue<UnitNanos>;
children?: SearchKnnCollectorResult[];
}
export interface SearchKnnQueryProfileBreakdown {
advance: long;
advance_count: long;
build_scorer: long;
build_scorer_count: long;
compute_max_score: long;
compute_max_score_count: long;
count_weight: long;
count_weight_count: long;
create_weight: long;
create_weight_count: long;
match: long;
match_count: long;
next_doc: long;
next_doc_count: long;
score: long;
score_count: long;
set_min_competitive_score: long;
set_min_competitive_score_count: long;
shallow_advance: long;
shallow_advance_count: long;
}
export interface SearchKnnQueryProfileResult {
type: string;
description: string;
time?: Duration;
time_in_nanos: DurationValue<UnitNanos>;
breakdown: SearchKnnQueryProfileBreakdown;
debug?: Record<string, any>;
children?: SearchKnnQueryProfileResult[];
}
export interface SearchLaplaceSmoothingModel {
alpha: double;
}
export interface SearchLearningToRank {
model_id: string;
params?: Record<string, any>;
}
export interface SearchLinearInterpolationSmoothingModel {
bigram_lambda: double;
trigram_lambda: double;
unigram_lambda: double;
}
export interface SearchNestedIdentity {
field: Field;
offset: integer;
_nested?: SearchNestedIdentity;
}
export interface SearchPhraseSuggest extends SearchSuggestBase {
options: SearchPhraseSuggestOption | SearchPhraseSuggestOption[];
}
export interface SearchPhraseSuggestCollate {
params?: Record<string, any>;
prune?: boolean;
query: SearchPhraseSuggestCollateQuery;
}
export interface SearchPhraseSuggestCollateQuery {
id?: Id;
source?: string;
}
export interface SearchPhraseSuggestHighlight {
post_tag: string;
pre_tag: string;
}
export interface SearchPhraseSuggestOption {
text: string;
score: double;
highlighted?: string;
collate_match?: boolean;
}
export interface SearchPhraseSuggester extends SearchSuggesterBase {
collate?: SearchPhraseSuggestCollate;
confidence?: double;
direct_generator?: SearchDirectGenerator[];
force_unigrams?: boolean;
gram_size?: integer;
highlight?: SearchPhraseSuggestHighlight;
max_errors?: double;
real_word_error_likelihood?: double;
separator?: string;
shard_size?: integer;
smoothing?: SearchSmoothingModelContainer;
text?: string;
token_limit?: integer;
}
export interface SearchPointInTimeReference {
id: Id;
keep_alive?: Duration;
}
export interface SearchProfile {
shards: SearchShardProfile[];
}
export interface SearchQueryBreakdown {
advance: long;
advance_count: long;
build_scorer: long;
build_scorer_count: long;
create_weight: long;
create_weight_count: long;
match: long;
match_count: long;
shallow_advance: long;
shallow_advance_count: long;
next_doc: long;
next_doc_count: long;
score: long;
score_count: long;
compute_max_score: long;
compute_max_score_count: long;
count_weight: long;
count_weight_count: long;
set_min_competitive_score: long;
set_min_competitive_score_count: long;
}
export interface SearchQueryProfile {
breakdown: SearchQueryBreakdown;
description: string;
time_in_nanos: DurationValue<UnitNanos>;
type: string;
children?: SearchQueryProfile[];
}
export interface SearchRegexOptions {
flags?: integer | string;
max_determinized_states?: integer;
}
export interface SearchRescore {
window_size?: integer;
query?: SearchRescoreQuery;
learning_to_rank?: SearchLearningToRank;
}
export interface SearchRescoreQuery {
rescore_query: QueryDslQueryContainer;
query_weight?: double;
rescore_query_weight?: double;
score_mode?: SearchScoreMode;
}
export type SearchScoreMode = 'avg' | 'max' | 'min' | 'multiply' | 'total';
export interface SearchSearchProfile {
collector: SearchCollector[];
query: SearchQueryProfile[];
rewrite_time: long;
}
export interface SearchShardProfile {
aggregations: SearchAggregationProfile[];
cluster: string;
dfs?: SearchDfsProfile;
fetch?: SearchFetchProfile;
id: string;
index: IndexName;
node_id: NodeId;
searches: SearchSearchProfile[];
shard_id: long;
}
export interface SearchSmoothingModelContainer {
laplace?: SearchLaplaceSmoothingModel;
linear_interpolation?: SearchLinearInterpolationSmoothingModel;
stupid_backoff?: SearchStupidBackoffSmoothingModel;
}
export type SearchSourceConfig = boolean | SearchSourceFilter | Fields;
export type SearchSourceConfigParam = boolean | Fields;
export interface SearchSourceFilter {
excludes?: Fields;
exclude?: Fields;
includes?: Fields;
include?: Fields;
}
export type SearchStringDistance = 'internal' | 'damerau_levenshtein' | 'levenshtein' | 'jaro_winkler' | 'ngram';
export interface SearchStupidBackoffSmoothingModel {
discount: double;
}
export type SearchSuggest<TDocument = unknown> = SearchCompletionSuggest<TDocument> | SearchPhraseSuggest | SearchTermSuggest;
export interface SearchSuggestBase {
length: integer;
offset: integer;
text: string;
}
export interface SearchSuggestFuzziness {
fuzziness?: Fuzziness;
min_length?: integer;
prefix_length?: integer;
transpositions?: boolean;
unicode_aware?: boolean;
}
export type SearchSuggestSort = 'score' | 'frequency';
export interface SearchSuggesterKeys {
text?: string;
}
export type SearchSuggester = SearchSuggesterKeys & {
[property: string]: SearchFieldSuggester | string;
};
export interface SearchSuggesterBase {
field: Field;
analyzer?: string;
size?: integer;
}
export interface SearchTermSuggest extends SearchSuggestBase {
options: SearchTermSuggestOption | SearchTermSuggestOption[];
}
export interface SearchTermSuggestOption {
text: string;
score: double;
freq: long;
highlighted?: string;
collate_match?: boolean;
}
export interface SearchTermSuggester extends SearchSuggesterBase {
lowercase_terms?: boolean;
max_edits?: integer;
max_inspections?: integer;
max_term_freq?: float;
min_doc_freq?: float;
min_word_length?: integer;
prefix_length?: integer;
shard_size?: integer;
sort?: SearchSuggestSort;
string_distance?: SearchStringDistance;
suggest_mode?: SuggestMode;
text?: string;
}
export interface SearchTotalHits {
relation: SearchTotalHitsRelation;
value: long;
}
export type SearchTotalHitsRelation = 'eq' | 'gte';
export type SearchTrackHits = boolean | integer;
export interface SearchMvtRequest extends RequestBase {
index: Indices;
field: Field;
zoom: SearchMvtZoomLevel;
x: SearchMvtCoordinate;
y: SearchMvtCoordinate;
aggs?: Record<string, AggregationsAggregationContainer>;
buffer?: integer;
exact_bounds?: boolean;
extent?: integer;
fields?: Fields;
grid_agg?: SearchMvtGridAggregationType;
grid_precision?: integer;
grid_type?: SearchMvtGridType;
query?: QueryDslQueryContainer;
runtime_mappings?: MappingRuntimeFields;
size?: integer;
sort?: Sort;
track_total_hits?: SearchTrackHits;
with_labels?: boolean;
}
export type SearchMvtResponse = MapboxVectorTiles;
export type SearchMvtCoordinate = integer;
export type SearchMvtGridAggregationType = 'geotile' | 'geohex';
export type SearchMvtGridType = 'grid' | 'point' | 'centroid';
export type SearchMvtZoomLevel = integer;
export interface SearchShardsRequest extends RequestBase {
index?: Indices;
allow_no_indices?: boolean;
expand_wildcards?: ExpandWildcards;
ignore_unavailable?: boolean;
local?: boolean;
preference?: string;
routing?: Routing;
}
export interface SearchShardsResponse {
nodes: Record<NodeId, SearchShardsSearchShardsNodeAttributes>;
shards: NodeShard[][];
indices: Record<IndexName, SearchShardsShardStoreIndex>;
}
export interface SearchShardsSearchShardsNodeA