elasticlink 0.8.0-beta → 1.0.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,1528 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/aggregation.builder.ts
+const sharedAggMethods = (state, rebuild) => ({
+	terms: (name, field, options) => rebuild({
+		...state,
+		[name]: { terms: {
+			field,
+			...options
+		} }
+	}),
+	dateHistogram: (name, field, options) => rebuild({
+		...state,
+		[name]: { date_histogram: {
+			field,
+			...options
+		} }
+	}),
+	range: (name, field, options) => rebuild({
+		...state,
+		[name]: { range: {
+			field,
+			...options
+		} }
+	}),
+	dateRange: (name, field, options) => rebuild({
+		...state,
+		[name]: { date_range: {
+			field,
+			...options
+		} }
+	}),
+	filters: (name, filters, options) => rebuild({
+		...state,
+		[name]: { filters: {
+			filters,
+			...options
+		} }
+	}),
+	significantTerms: (name, field, options) => rebuild({
+		...state,
+		[name]: { significant_terms: {
+			field,
+			...options
+		} }
+	}),
+	histogram: (name, field, options) => rebuild({
+		...state,
+		[name]: { histogram: {
+			field,
+			...options
+		} }
+	}),
+	avg: (name, field, options) => rebuild({
+		...state,
+		[name]: { avg: {
+			field,
+			...options
+		} }
+	}),
+	sum: (name, field, options) => rebuild({
+		...state,
+		[name]: { sum: {
+			field,
+			...options
+		} }
+	}),
+	min: (name, field, options) => rebuild({
+		...state,
+		[name]: { min: {
+			field,
+			...options
+		} }
+	}),
+	max: (name, field, options) => rebuild({
+		...state,
+		[name]: { max: {
+			field,
+			...options
+		} }
+	}),
+	cardinality: (name, field, options) => rebuild({
+		...state,
+		[name]: { cardinality: {
+			field,
+			...options
+		} }
+	}),
+	percentiles: (name, field, options) => rebuild({
+		...state,
+		[name]: { percentiles: {
+			field,
+			...options
+		} }
+	}),
+	stats: (name, field, options) => rebuild({
+		...state,
+		[name]: { stats: {
+			field,
+			...options
+		} }
+	}),
+	valueCount: (name, field, options) => rebuild({
+		...state,
+		[name]: { value_count: {
+			field,
+			...options
+		} }
+	}),
+	extendedStats: (name, field, options) => rebuild({
+		...state,
+		[name]: { extended_stats: {
+			field,
+			...options
+		} }
+	}),
+	topHits: (name, options) => rebuild({
+		...state,
+		[name]: { top_hits: { ...options } }
+	}),
+	autoDateHistogram: (name, field, options) => rebuild({
+		...state,
+		[name]: { auto_date_histogram: {
+			field,
+			...options
+		} }
+	}),
+	composite: (name, sources, options) => rebuild({
+		...state,
+		[name]: { composite: {
+			sources,
+			...options
+		} }
+	}),
+	filter: (name, query) => rebuild({
+		...state,
+		[name]: { filter: query }
+	}),
+	rareTerms: (name, field, options) => rebuild({
+		...state,
+		[name]: { rare_terms: {
+			field,
+			...options
+		} }
+	}),
+	multiTerms: (name, options) => rebuild({
+		...state,
+		[name]: { multi_terms: { ...options } }
+	}),
+	geoDistance: (name, field, options) => rebuild({
+		...state,
+		[name]: { geo_distance: {
+			field,
+			...options
+		} }
+	}),
+	geohashGrid: (name, field, options) => rebuild({
+		...state,
+		[name]: { geohash_grid: {
+			field,
+			...options
+		} }
+	}),
+	geotileGrid: (name, field, options) => rebuild({
+		...state,
+		[name]: { geotile_grid: {
+			field,
+			...options
+		} }
+	}),
+	geoBounds: (name, field, options) => rebuild({
+		...state,
+		[name]: { geo_bounds: {
+			field,
+			...options
+		} }
+	}),
+	geoCentroid: (name, field, options) => rebuild({
+		...state,
+		[name]: { geo_centroid: {
+			field,
+			...options
+		} }
+	}),
+	missing: (name, field, options) => rebuild({
+		...state,
+		[name]: { missing: {
+			field,
+			...options
+		} }
+	}),
+	topMetrics: (name, options) => rebuild({
+		...state,
+		[name]: { top_metrics: { ...options } }
+	}),
+	weightedAvg: (name, options) => rebuild({
+		...state,
+		[name]: { weighted_avg: { ...options } }
+	}),
+	bucketScript: (name, options) => rebuild({
+		...state,
+		[name]: { bucket_script: { ...options } }
+	}),
+	bucketSelector: (name, options) => rebuild({
+		...state,
+		[name]: { bucket_selector: { ...options } }
+	}),
+	derivative: (name, options) => rebuild({
+		...state,
+		[name]: { derivative: { ...options } }
+	}),
+	cumulativeSum: (name, options) => rebuild({
+		...state,
+		[name]: { cumulative_sum: { ...options } }
+	}),
+	build: () => state
+});
+const attachSubAgg = (state, subAggState) => {
+	const lastKey = Object.keys(state).at(-1);
+	const existing = state[lastKey].aggs ?? {};
+	return {
+		...state,
+		[lastKey]: {
+			...state[lastKey],
+			aggs: {
+				...existing,
+				...subAggState
+			}
+		}
+	};
+};
+function createNestedEntryBuilder(state, rebuild) {
+	return {
+		...sharedAggMethods(state, rebuild),
+		global: (name) => createAggregationBuilder({
+			...state,
+			[name]: { global: {} }
+		}),
+		nested: (name, path) => createNestedEntryBuilder({
+			...state,
+			[name]: { nested: { path } }
+		}, rebuild),
+		subAgg: (fn) => rebuild(attachSubAgg(state, fn(createNestedAggregationBuilder()).build()))
+	};
+}
+function createNestedAggregationBuilder(state = {}) {
+	return {
+		...sharedAggMethods(state, createNestedAggregationBuilder),
+		nested: (name, path) => createNestedEntryBuilder({
+			...state,
+			[name]: { nested: { path } }
+		}, createNestedAggregationBuilder),
+		reverseNested: (name, path) => createNestedAggregationBuilder({
+			...state,
+			[name]: { reverse_nested: path ? { path } : {} }
+		}),
+		subAgg: (fn) => createNestedAggregationBuilder(attachSubAgg(state, fn(createNestedAggregationBuilder()).build()))
+	};
+}
+function createAggregationBuilder(state = {}) {
+	return {
+		...sharedAggMethods(state, createAggregationBuilder),
+		global: (name) => createAggregationBuilder({
+			...state,
+			[name]: { global: {} }
+		}),
+		nested: (name, path) => createNestedEntryBuilder({
+			...state,
+			[name]: { nested: { path } }
+		}, createAggregationBuilder),
+		subAgg: (fn) => createAggregationBuilder(attachSubAgg(state, fn(createAggregationBuilder()).build()))
+	};
+}
+const aggregations = (_schema) => createAggregationBuilder();
+//#endregion
+//#region src/suggester.builder.ts
+/**
+* Creates a suggester builder
+* @returns SuggesterBuilder instance
+*/
+const createSuggesterBuilder = (state = {}) => ({
+	term: (name, text, options) => {
+		return createSuggesterBuilder({
+			...state,
+			[name]: {
+				text,
+				term: options
+			}
+		});
+	},
+	phrase: (name, text, options) => {
+		return createSuggesterBuilder({
+			...state,
+			[name]: {
+				text,
+				phrase: options
+			}
+		});
+	},
+	completion: (name, prefix, options) => {
+		return createSuggesterBuilder({
+			...state,
+			[name]: {
+				prefix,
+				completion: options
+			}
+		});
+	},
+	build: () => ({ suggest: state })
+});
+/**
+* Factory function to create a new suggester builder
+* @example
+* ```typescript
+* const suggestions = suggest(productMappings)
+*   .term('name-suggestions', 'laptop', { field: 'name', size: 5 })
+*   .build();
+* ```
+*/
+const suggest = (_schema) => createSuggesterBuilder();
+//#endregion
+//#region src/query.builder.ts
+const resolveCondition = (c) => typeof c === "function" ? resolveCondition(c()) : typeof c === "boolean" ? c : c != null;
+const createClauseMethods = (wrap, qualifyField = (f) => f) => ({
+	matchAll: () => wrap({ match_all: {} }),
+	matchNone: () => wrap({ match_none: {} }),
+	match: (field, value, options) => wrap({ match: { [qualifyField(field)]: options ? {
+		query: value,
+		...options
+	} : value } }),
+	multiMatch: (fields, query, options) => wrap({ multi_match: {
+		fields: fields.map(qualifyField),
+		query,
+		...options
+	} }),
+	matchPhrase: (field, query) => wrap({ match_phrase: { [qualifyField(field)]: query } }),
+	matchPhrasePrefix: (field, value, options) => wrap({ match_phrase_prefix: { [qualifyField(field)]: options ? {
+		query: value,
+		...options
+	} : value } }),
+	term: (field, value) => wrap({ term: { [qualifyField(field)]: value } }),
+	terms: (field, value) => wrap({ terms: { [qualifyField(field)]: value } }),
+	range: (field, conditions) => wrap({ range: { [qualifyField(field)]: conditions } }),
+	exists: (field) => wrap({ exists: { field: qualifyField(field) } }),
+	prefix: (field, value) => wrap({ prefix: { [qualifyField(field)]: value } }),
+	wildcard: (field, value) => wrap({ wildcard: { [qualifyField(field)]: value } }),
+	fuzzy: (field, value, options) => wrap({ fuzzy: { [qualifyField(field)]: options ? {
+		value,
+		...options
+	} : { value } } }),
+	ids: (values) => wrap({ ids: { values } }),
+	script: (options) => {
+		const { source, lang = "painless", params, boost } = options;
+		return wrap({ script: {
+			script: {
+				source,
+				lang,
+				...params !== void 0 && { params }
+			},
+			...boost !== void 0 && { boost }
+		} });
+	},
+	combinedFields: (fields, query, options) => wrap({ combined_fields: {
+		fields: fields.map(qualifyField),
+		query,
+		...options
+	} }),
+	queryString: (query, options) => wrap({ query_string: {
+		query,
+		...options
+	} }),
+	simpleQueryString: (query, options) => wrap({ simple_query_string: {
+		query,
+		...options
+	} }),
+	moreLikeThis: (fields, like, options) => wrap({ more_like_this: {
+		fields: fields.map(qualifyField),
+		like: Array.isArray(like) ? like : [like],
+		...options
+	} }),
+	matchBoolPrefix: (field, value, options) => wrap({ match_bool_prefix: { [qualifyField(field)]: options ? {
+		query: value,
+		...options
+	} : value } }),
+	regexp: (field, value, options) => wrap({ regexp: { [qualifyField(field)]: options ? {
+		value,
+		...options
+	} : value } }),
+	geoDistance: (field, center, options) => wrap({ geo_distance: {
+		[qualifyField(field)]: center,
+		...options
+	} }),
+	geoBoundingBox: (field, options) => wrap({ geo_bounding_box: { [qualifyField(field)]: options } }),
+	geoPolygon: (field, options) => wrap({ geo_polygon: { [qualifyField(field)]: options } }),
+	geoShape: (field, shape, options) => wrap({ geo_shape: { [qualifyField(field)]: {
+		shape,
+		...options
+	} } }),
+	distanceFeature: (field, options) => wrap({ distance_feature: {
+		field: qualifyField(field),
+		...options
+	} }),
+	rankFeature: (field, options) => wrap({ rank_feature: {
+		field: qualifyField(field),
+		...options
+	} }),
+	sparseVector: (field, options) => wrap({ sparse_vector: {
+		field: qualifyField(field),
+		...options
+	} }),
+	intervals: (field, options) => wrap({ intervals: { [qualifyField(field)]: options } }),
+	spanTerm: (field, value) => wrap({ span_term: { [qualifyField(field)]: { value } } }),
+	spanNear: (clauses, options) => wrap({ span_near: {
+		clauses: [...clauses],
+		...options
+	} }),
+	spanOr: (clauses) => wrap({ span_or: { clauses: [...clauses] } }),
+	spanNot: (include, exclude, options) => wrap({ span_not: {
+		include,
+		exclude,
+		...options
+	} }),
+	spanFirst: (match, end) => wrap({ span_first: {
+		match,
+		end
+	} }),
+	spanContaining: (big, little) => wrap({ span_containing: {
+		big,
+		little
+	} }),
+	spanWithin: (big, little) => wrap({ span_within: {
+		big,
+		little
+	} }),
+	spanMultiTerm: (query) => wrap({ span_multi: { match: query } }),
+	spanFieldMasking: (field, query) => wrap({ span_field_masking: {
+		field: qualifyField(field),
+		query
+	} })
+});
+const createClauseBuilder = (prefix) => {
+	const qualifyField = prefix ? (f) => `${prefix}.${f}` : (f) => f;
+	return {
+		...createClauseMethods((dsl) => dsl, qualifyField),
+		knn: (field, queryVector, options) => {
+			const { k, num_candidates, ...restOptions } = options;
+			return { knn: {
+				field: qualifyField(field),
+				query_vector: queryVector,
+				k,
+				num_candidates,
+				...restOptions
+			} };
+		},
+		nested: (path, fn, options) => {
+			const nestedPath = prefix ? `${prefix}.${path}` : path;
+			const nestedQuery = fn(createClauseBuilder(nestedPath));
+			return nestedQuery === void 0 ? void 0 : { nested: {
+				path: nestedPath,
+				query: nestedQuery,
+				...options
+			} };
+		},
+		functionScore: (queryFn, options) => {
+			return { function_score: {
+				query: queryFn(createClauseBuilder(prefix)) ?? { match_all: {} },
+				...options
+			} };
+		},
+		hasChild: (type, queryFn, options) => {
+			return { has_child: {
+				type,
+				query: queryFn(createClauseBuilder()) ?? { match_all: {} },
+				...options
+			} };
+		},
+		hasParent: (type, queryFn, options) => {
+			return { has_parent: {
+				parent_type: type,
+				query: queryFn(createClauseBuilder()) ?? { match_all: {} },
+				...options
+			} };
+		},
+		parentId: (type, id, options) => ({ parent_id: {
+			type,
+			id,
+			...options
+		} }),
+		when: (condition, thenFn) => resolveCondition(condition) ? thenFn(createClauseBuilder(prefix)) : void 0
+	};
+};
+const createQueryBuilder = (state = {}) => {
+	const q = state.query ?? {};
+	return {
+		...createClauseMethods((dsl) => createQueryBuilder({
+			...state,
+			query: dsl
+		})),
+		bool: () => createQueryBuilder({
+			...state,
+			query: { bool: {} }
+		}),
+		must: (builderFn) => {
+			const clause = builderFn(createClauseBuilder());
+			const existing = q.bool?.must ?? [];
+			return clause === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				query: { bool: {
+					...q.bool,
+					must: [...existing, clause]
+				} }
+			});
+		},
+		mustNot: (builderFn) => {
+			const clause = builderFn(createClauseBuilder());
+			const existing = q.bool?.must_not ?? [];
+			return clause === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				query: { bool: {
+					...q.bool,
+					must_not: [...existing, clause]
+				} }
+			});
+		},
+		should: (builderFn) => {
+			const clause = builderFn(createClauseBuilder());
+			const existing = q.bool?.should ?? [];
+			return clause === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				query: { bool: {
+					...q.bool,
+					should: [...existing, clause]
+				} }
+			});
+		},
+		filter: (builderFn) => {
+			const clause = builderFn(createClauseBuilder());
+			const existing = q.bool?.filter ?? [];
+			return clause === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				query: { bool: {
+					...q.bool,
+					filter: [...existing, clause]
+				} }
+			});
+		},
+		minimumShouldMatch: (value) => createQueryBuilder({
+			...state,
+			query: { bool: {
+				...q.bool,
+				minimum_should_match: value
+			} }
+		}),
+		knn: (field, queryVector, options) => {
+			const { k, num_candidates, ...restOptions } = options;
+			return createQueryBuilder({
+				...state,
+				knn: {
+					field,
+					query_vector: queryVector,
+					k,
+					num_candidates,
+					...restOptions
+				}
+			});
+		},
+		nested: (path, fn, options) => {
+			const nestedQuery = fn(createClauseBuilder(path));
+			return nestedQuery === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				query: { nested: {
+					path,
+					query: nestedQuery,
+					...options
+				} }
+			});
+		},
+		scriptScore: (queryFn, script, options) => {
+			const innerQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
+			const { source, lang = "painless", params } = script;
+			return createQueryBuilder({
+				...state,
+				query: { script_score: {
+					query: innerQuery,
+					script: {
+						source,
+						lang,
+						...params !== void 0 && { params }
+					},
+					...options?.min_score !== void 0 && { min_score: options.min_score },
+					...options?.boost !== void 0 && { boost: options.boost }
+				} }
+			});
+		},
+		percolate: (options) => createQueryBuilder({
+			...state,
+			query: { percolate: { ...options } }
+		}),
+		functionScore: (queryFn, options) => {
+			const innerQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
+			return createQueryBuilder({
+				...state,
+				query: { function_score: {
+					query: innerQuery,
+					...options
+				} }
+			});
+		},
+		hasChild: (type, queryFn, options) => {
+			const childQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
+			return createQueryBuilder({
+				...state,
+				query: { has_child: {
+					type,
+					query: childQuery,
+					...options
+				} }
+			});
+		},
+		hasParent: (type, queryFn, options) => {
+			const parentQuery = queryFn(createClauseBuilder()) ?? { match_all: {} };
+			return createQueryBuilder({
+				...state,
+				query: { has_parent: {
+					parent_type: type,
+					query: parentQuery,
+					...options
+				} }
+			});
+		},
+		parentId: (type, id, options) => createQueryBuilder({
+			...state,
+			query: { parent_id: {
+				type,
+				id,
+				...options
+			} }
+		}),
+		when: (condition, thenFn) => resolveCondition(condition) ? thenFn(createQueryBuilder(state)) : createQueryBuilder(state),
+		sort: (field, direction = "asc") => {
+			const existing = state.sort || [];
+			return createQueryBuilder({
+				...state,
+				sort: [...existing, { [field]: direction }]
+			});
+		},
+		from: (from) => createQueryBuilder({
+			...state,
+			from
+		}),
+		size: (size) => createQueryBuilder({
+			...state,
+			size
+		}),
+		_source: (_source) => createQueryBuilder({
+			...state,
+			_source
+		}),
+		sourceIncludes: (paths) => createQueryBuilder({
+			...state,
+			_source_includes: paths
+		}),
+		sourceExcludes: (paths) => createQueryBuilder({
+			...state,
+			_source_excludes: paths
+		}),
+		runtimeMappings: (runtime_mappings) => createQueryBuilder({
+			...state,
+			runtime_mappings
+		}),
+		docValueFields: (docvalue_fields) => createQueryBuilder({
+			...state,
+			docvalue_fields
+		}),
+		fields: (fields) => createQueryBuilder({
+			...state,
+			fields
+		}),
+		postFilter: (fn) => {
+			const clause = fn(createClauseBuilder());
+			return clause === void 0 ? createQueryBuilder(state) : createQueryBuilder({
+				...state,
+				post_filter: clause
+			});
+		},
+		scriptFields: (script_fields) => createQueryBuilder({
+			...state,
+			script_fields
+		}),
+		timeout: (timeout) => createQueryBuilder({
+			...state,
+			timeout
+		}),
+		trackScores: (track_scores) => createQueryBuilder({
+			...state,
+			track_scores
+		}),
+		explain: (explain) => createQueryBuilder({
+			...state,
+			explain
+		}),
+		minScore: (min_score) => createQueryBuilder({
+			...state,
+			min_score
+		}),
+		version: (version) => createQueryBuilder({
+			...state,
+			version
+		}),
+		seqNoPrimaryTerm: (seq_no_primary_term) => createQueryBuilder({
+			...state,
+			seq_no_primary_term
+		}),
+		trackTotalHits: (track_total_hits = true) => createQueryBuilder({
+			...state,
+			track_total_hits
+		}),
+		highlight: (fields, options) => {
+			const { pre_tags, post_tags, ...fieldOptions } = options || {};
+			const fieldValue = Object.keys(fieldOptions).length > 0 ? fieldOptions : {};
+			const highlightFields = Object.fromEntries(fields.map((field) => [field, fieldValue]));
+			return createQueryBuilder({
+				...state,
+				highlight: {
+					fields: highlightFields,
+					...pre_tags && { pre_tags },
+					...post_tags && { post_tags }
+				}
+			});
+		},
+		constantScore: (fn, options) => {
+			const clause = fn(createClauseBuilder());
+			return createQueryBuilder({
+				...state,
+				query: { constant_score: {
+					filter: clause,
+					...options
+				} }
+			});
+		},
+		searchAfter: (values) => createQueryBuilder({
+			...state,
+			search_after: values
+		}),
+		preference: (value) => createQueryBuilder({
+			...state,
+			preference: value
+		}),
+		collapse: (field, options) => createQueryBuilder({
+			...state,
+			collapse: {
+				field,
+				...options
+			}
+		}),
+		rescore: (queryFn, windowSize, options) => {
+			const rescoreQuery = queryFn(createClauseBuilder());
+			return createQueryBuilder({
+				...state,
+				rescore: {
+					window_size: windowSize,
+					query: {
+						rescore_query: rescoreQuery,
+						...options
+					}
+				}
+			});
+		},
+		storedFields: (fields) => createQueryBuilder({
+			...state,
+			stored_fields: fields
+		}),
+		terminateAfter: (count) => createQueryBuilder({
+			...state,
+			terminate_after: count
+		}),
+		pit: (id, keepAlive) => createQueryBuilder({
+			...state,
+			pit: {
+				id,
+				keep_alive: keepAlive
+			}
+		}),
+		indicesBoost: (boosts) => createQueryBuilder({
+			...state,
+			indices_boost: boosts
+		}),
+		aggs: (fn) => {
+			const builtAggs = fn(createAggregationBuilder()).build();
+			return createQueryBuilder({
+				...state,
+				aggs: builtAggs
+			});
+		},
+		suggest: (fn) => {
+			const builtSuggestions = fn(createSuggesterBuilder()).build();
+			return createQueryBuilder({
+				...state,
+				suggest: builtSuggestions.suggest
+			});
+		},
+		build: () => {
+			const { _includeQuery, ...rest } = state;
+			if (_includeQuery === false) {
+				const { query: _q, ...noQuery } = rest;
+				return noQuery;
+			}
+			return rest;
+		}
+	};
+};
+//#endregion
+//#region src/mapping.builder.ts
+const mappings = (fields, options) => {
+	return {
+		_fieldTypes: void 0,
+		_fields: void 0,
+		properties: { ...fields },
+		_mappingOptions: {
+			dynamic: "strict",
+			...options
+		}
+	};
+};
+//#endregion
+//#region src/field.helpers.ts
+const text = (options) => ({
+	type: "text",
+	...options
+});
+const keyword = (options) => ({
+	type: "keyword",
+	...options
+});
+const long = (options) => ({
+	type: "long",
+	...options
+});
+const integer = (options) => ({
+	type: "integer",
+	...options
+});
+const short = (options) => ({
+	type: "short",
+	...options
+});
+const byte = (options) => ({
+	type: "byte",
+	...options
+});
+const double = (options) => ({
+	type: "double",
+	...options
+});
+const float = (options) => ({
+	type: "float",
+	...options
+});
+const halfFloat = (options) => ({
+	type: "half_float",
+	...options
+});
+const scaledFloat = (options) => ({
+	type: "scaled_float",
+	...options
+});
+const date = (options) => ({
+	type: "date",
+	...options
+});
+/**
+* Date field stored with nanosecond precision. Same API as `date()` but supports sub-millisecond timestamps.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/date_nanos.html
+*/
+const dateNanos = (options) => ({
+	type: "date_nanos",
+	...options
+});
+const boolean = (options) => ({
+	type: "boolean",
+	...options
+});
+const binary = () => ({ type: "binary" });
+const ip = (options) => ({
+	type: "ip",
+	...options
+});
+const denseVector = (options) => ({
+	type: "dense_vector",
+	...options
+});
+/**
+* Quantized dense vector field — wraps `denseVector()` with `int8_hnsw` index type.
+*
+* Quantizes float32 vectors to int8 at index time, saving ~75% memory.
+* Recommended for vectors with dims >= 384. Original float vectors are retained
+* in the index, enabling a two-phase search pattern:
+*
+* 1. Fast approximate search using quantized int8 vectors
+* 2. Precise rescore of top-k results using retained float vectors
+*
+* @example
+* // Index mapping
+* const schema = mappings({
+*   title: text(),
+*   embedding: quantizedDenseVector({ dims: 768, similarity: 'cosine' }),
+* }, {
+*   _source: { excludes: ['embedding'] },
+* });
+*
+* // Two-phase search: fast kNN + precise rescore
+* const result = queryBuilder(schema)
+*   .knn('embedding', queryVector, { k: 100, num_candidates: 200 })
+*   .rescore(
+*     (q) => q.scriptScore(
+*       (inner) => inner.matchAll(),
+*       { source: "cosineSimilarity(params.v, 'embedding') + 1.0", params: { v: queryVector } }
+*     ),
+*     100
+*   )
+*   .build();
+*/
+const quantizedDenseVector = (options) => ({
+	type: "dense_vector",
+	...options,
+	index_options: {
+		type: "int8_hnsw",
+		...options?.index_options
+	}
+});
+/**
+* Sparse vector field — stores token-weight pairs for sparse retrieval (e.g. ELSER/BM25-style models).
+* Complement to `denseVector()`. Query with the `sparse_vector` query.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/sparse-vector.html
+*/
+const sparseVector = () => ({ type: "sparse_vector" });
+/**
+* Rank feature field — a single numeric feature used by the `rank_feature` query to boost relevance.
+* Use when each document has one named signal (e.g. `pagerank`, `popularity_score`).
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/rank-feature.html
+*/
+const rankFeature = (options) => ({
+	type: "rank_feature",
+	...options
+});
+/**
+* Rank features field — a sparse map of numeric features used by the `rank_feature` query.
+* Use when each document has many named signals (e.g. topic scores).
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/rank-features.html
+*/
+const rankFeatures = (options) => ({
+	type: "rank_features",
+	...options
+});
+/**
+* Semantic text field (ES 9.x) — ML-powered text field for semantic and hybrid search.
+* Automatically generates and stores embeddings at index time using the configured inference endpoint.
+*
+* @example
+* const schema = mappings({
+*   title: text(),
+*   body: semanticText({ inference_id: 'my-elser-endpoint' }),
+* });
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/semantic-text.html
+*/
+const semanticText = (options) => ({
+	type: "semantic_text",
+	...options
+});
+/**
+* Unsigned long field (ES 9.0+) — stores unsigned 64-bit integer values (0 to 2^64-1).
+* Use when values exceed the `long` range.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/number.html
+*/
+const unsignedLong = (options) => ({
+	type: "unsigned_long",
+	...options
+});
+const geoPoint = (options) => ({
+	type: "geo_point",
+	...options
+});
+const geoShape = (options) => ({
+	type: "geo_shape",
+	...options
+});
+const completion = (options) => ({
+	type: "completion",
+	...options
+});
+/**
+* Object field — for JSON-like structured documents where sub-fields are queried with dot-notation.
+*
+* The most common way to model structured data (e.g. `{ address: { city, zip } }`).
+* Sub-fields are indexed inline within the parent document — no special query wrapper needed.
+* Query sub-fields directly using dot-notation: `.term('address.city', 'NYC')`.
+*
+* Use `nested()` instead when you have **arrays of objects** and need cross-field queries
+* within each element to be accurate (e.g. tags with both a label and weight).
+*
+* @example
+* const m = mappings({
+*   address: object({
+*     street: text(),
+*     city: keyword(),
+*     zip: keyword(),
+*   }),
+* });
+* queryBuilder(m).term('address.city', 'NYC').build();
+*/
+function object(fields, options) {
+	return {
+		type: "object",
+		...options ?? {},
+		properties: fields
+	};
+}
+/**
+* Nested field — for **arrays of objects** where cross-field queries within each element must be accurate.
+*
+* Each nested object is stored as a separate hidden Elasticsearch document, preserving the
+* relationship between sub-fields within each element. Without `nested`, Elasticsearch flattens
+* array sub-fields and loses which values belong to the same element.
+*
+* Queries on nested fields **must** use the `.nested()` query builder method — direct dot-notation
+* queries will not find nested documents.
+*
+* Use `object()` instead for single structured objects (addresses, names, etc.) — it is simpler,
+* more efficient, and does not require a query wrapper.
+*
+* @example
+* const m = mappings({
+*   tags: nested({
+*     label: keyword(),
+*     weight: float(),
+*   }),
+* });
+* queryBuilder(m).nested('tags', q => q.term('label', 'sale')).build();
+*/
+function nested(fields, options) {
+	return {
+		type: "nested",
+		...options ?? {},
+		properties: fields
+	};
+}
+const alias = (options) => ({
+	type: "alias",
+	...options
+});
+const percolator = () => ({ type: "percolator" });
+const integerRange = (options) => ({
+	type: "integer_range",
+	...options
+});
+const floatRange = (options) => ({
+	type: "float_range",
+	...options
+});
+const longRange = (options) => ({
+	type: "long_range",
+	...options
+});
+const doubleRange = (options) => ({
+	type: "double_range",
+	...options
+});
+const dateRange = (options) => ({
+	type: "date_range",
+	...options
+});
+/**
+* IP range field — stores a range of IPv4/IPv6 addresses.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/range.html
+*/
+const ipRange = (options) => ({
+	type: "ip_range",
+	...options
+});
+/**
+* No-score text field — faster and uses less disk than `text()`.
+* Use when you only need filter/match but not relevance scoring (e.g., logs, simple field matches).
+*/
+const matchOnlyText = (options) => ({
+	type: "match_only_text",
+	...options
+});
+/**
+* Autocomplete / typeahead field. Creates sub-fields for edge n-gram matching
+* out of the box. Query with `multi_match` targeting the generated sub-fields.
+*/
+const searchAsYouType = (options) => ({
+	type: "search_as_you_type",
+	...options
+});
+/**
+* Field where every document has the same value. Useful for multi-index queries
+* to identify the index type (e.g., `constantKeyword({ value: 'product' })`).
+*/
+const constantKeyword = (options) => ({
+	type: "constant_keyword",
+	...options
+});
+/**
+* Optimized for grep-like wildcard/regexp queries on high-cardinality or large fields.
+* Use instead of `keyword()` when leading wildcards (`*foo`) are needed.
+*/
+const wildcardField = (options) => ({
+	type: "wildcard",
+	...options
+});
+/**
+* Flattens complex/dynamic objects into a single field. Faster than `nested()`,
+* but only supports keyword-level queries on inner values.
+*/
+const flattened = (options) => ({
+	type: "flattened",
+	...options
+});
+/**
+* Token count field — stores the number of tokens produced by an analyzer.
+* Useful for enforcing minimum/maximum field lengths via queries or aggregations.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/token-count.html
+*/
+const tokenCount = (options) => ({
+	type: "token_count",
+	...options
+});
+/**
+* Murmur3 hash field — computes and stores a murmur3 hash of field values at index time.
+* Requires the `mapper-murmur3` plugin.
+* @see https://www.elastic.co/guide/en/elasticsearch/plugins/current/mapper-murmur3.html
+*/
+const murmur3Hash = () => ({ type: "murmur3" });
+/**
+* Join field — defines parent/child relationships within a single index.
+* `relations` is required: maps parent names to one or more child names.
+* @see https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html
+*
+* @example
+* const m = mappings({
+*   title: text(),
+*   relation: join({ relations: { question: 'answer' } }),
+* });
+*/
+const join = (options) => ({
+	type: "join",
+	...options
+});
+//#endregion
+//#region src/multi-search.builder.ts
+/**
+* Creates a multi-search builder
+* @returns MSearchBuilder instance
+*/
+const createMSearchBuilder = (searches = [], params = {}) => ({
+	add: (request) => {
+		return createMSearchBuilder([...searches, request], params);
+	},
+	addQuery: (body, header = {}) => {
+		return createMSearchBuilder([...searches, {
+			header,
+			body
+		}], params);
+	},
+	addQueryBuilder: (qb, header = {}) => {
+		return createMSearchBuilder([...searches, {
+			header,
+			body: qb.build()
+		}], params);
+	},
+	withParams: (next) => {
+		return createMSearchBuilder(searches, {
+			...params,
+			...next
+		});
+	},
+	build: () => {
+		return `${searches.map(({ header, body }) => {
+			return `${JSON.stringify(header || {})}\n${JSON.stringify(body)}`;
+		}).join("\n")}\n`;
+	},
+	buildArray: () => {
+		return searches.flatMap(({ header, body }) => [header || {}, body]);
+	},
+	buildParams: () => params
+});
+/**
+* Create a new multi-search builder
+* @example
+* const ms = msearch(productMappings)
+*   .addQueryBuilder(queryBuilder(productMappings).match('name', 'shoe'), { index: 'products' })
+*   .addQueryBuilder(queryBuilder(productMappings).match('name', 'shirt'), { index: 'products' })
+*   .withParams({ max_concurrent_searches: 5, typed_keys: true })
+*   .build();
+*/
+const msearch = (_schema) => createMSearchBuilder();
+//#endregion
+//#region src/bulk.builder.ts
+/**
+* Creates a bulk operations builder
+* @returns BulkBuilder instance
+*/
+const createBulkBuilder = (operations = []) => ({
+	index: (doc, meta = {}) => {
+		return createBulkBuilder([
+			...operations,
+			{ index: meta },
+			doc
+		]);
+	},
+	create: (doc, meta = {}) => {
+		return createBulkBuilder([
+			...operations,
+			{ create: meta },
+			doc
+		]);
+	},
+	update: (meta) => {
+		const { doc, script, upsert, doc_as_upsert, detect_noop, scripted_upsert, _source, ...header } = meta;
+		const updateDoc = {
+			...doc && { doc },
+			...script && { script },
+			...upsert && { upsert },
+			...doc_as_upsert !== void 0 && { doc_as_upsert },
+			...detect_noop !== void 0 && { detect_noop },
+			...scripted_upsert !== void 0 && { scripted_upsert },
+			..._source !== void 0 && { _source }
+		};
+		return createBulkBuilder([
+			...operations,
+			{ update: header },
+			updateDoc
+		]);
+	},
+	delete: (meta) => {
+		return createBulkBuilder([...operations, { delete: meta }]);
+	},
+	build: () => {
+		return `${operations.map((op) => JSON.stringify(op)).join("\n")}\n`;
+	},
+	buildArray: () => operations
+});
+/**
+* Create a new bulk operations builder.
+* `.build()` returns an NDJSON string (newline-delimited JSON) ready to POST to `/_bulk`.
+* `.buildArray()` returns the raw operation objects if you need to inspect or transform them.
+* @example
+* const ndjson = bulk(productMappings)
+*   .index({ id: '1', name: 'Product 1' }, { _index: 'products', _id: '1' })
+*   .create({ id: '2', name: 'Product 2' }, { _index: 'products', _id: '2' })
+*   .update({ _index: 'products', _id: '3', doc: { name: 'Updated' } })
+*   .delete({ _index: 'products', _id: '4' })
+*   .build(); // POST to /_bulk with Content-Type: application/x-ndjson
+*/
+const bulk = (_schema) => createBulkBuilder();
+//#endregion
+//#region src/index-management.builder.ts
+const isMappingsSchema = (input) => "_fieldTypes" in input;
+/**
+* Creates an index builder.
+*
+* The optional generic `M` carries the field-type map from any mapping schema attached
+* via `.mappings(schema)`. `.mappings()` rebinds the generic to the incoming schema's
+* field-type map, so callers typically rely on inference rather than specifying `M` directly.
+*
+* @returns IndexBuilder instance
+*/
+const createIndexBuilder = (state = {}) => ({
+	mappings: (schemaOrFields, inlineOptions) => {
+		const rawProperties = isMappingsSchema(schemaOrFields) ? schemaOrFields.properties : schemaOrFields;
+		const properties = Object.fromEntries(Object.entries(rawProperties).filter(([, v]) => v !== void 0));
+		const mappingOptions = {
+			dynamic: "strict",
+			...isMappingsSchema(schemaOrFields) ? schemaOrFields._mappingOptions : void 0,
+			...inlineOptions
+		};
+		return createIndexBuilder({
+			...state,
+			mappings: {
+				properties,
+				...mappingOptions.dynamic !== void 0 && { dynamic: mappingOptions.dynamic },
+				...mappingOptions._source !== void 0 && { _source: mappingOptions._source },
+				...mappingOptions._meta && { _meta: mappingOptions._meta }
+			}
+		});
+	},
+	settings: (settings) => createIndexBuilder({
+		...state,
+		settings
+	}),
+	analysis: (config) => createIndexBuilder({
+		...state,
+		settings: {
+			...state.settings,
+			analysis: config
+		}
+	}),
+	alias: (name, options = {}) => {
+		const aliases = state.aliases || {};
+		return createIndexBuilder({
+			...state,
+			aliases: {
+				...aliases,
+				[name]: options
+			}
+		});
+	},
+	build: () => state
+});
+/**
+* Create a new index builder for Elasticsearch index configuration.
+*
+* Typical lifecycle:
+* 1. **Create index:** `indexBuilder().mappings(schema).settings(productionSearchSettings()).build()`
+* 2. **Bulk ingest:** Apply `fastIngestSettings()` via ES `_settings` API → bulk index →
+*    apply `productionSearchSettings()` → `POST /index/_refresh`
+* 3. **Normal operations:** Query, update individual docs via `_update` API
+* 4. **Migration with mapping changes:** Create new index with new mappings → `POST _reindex`
+*    from old → atomically swap alias via `POST _aliases` → delete old index
+*
+* After bulk loading, remember to refresh the index with `POST /index/_refresh`
+* to make all documents searchable.
+*
+* @example
+* const indexConfig = indexBuilder()
+*   .mappings(productMappings)
+*   .settings(productionSearchSettings())
+*   .alias('products')
+*   .build();
+*/
+const indexBuilder = () => createIndexBuilder();
+//#endregion
+//#region src/settings.presets.ts
+/**
+* Balanced production settings for search workloads.
+*
+* Defaults:
+* - `number_of_replicas: 1` — one replica for redundancy
+* - `refresh_interval: '5s'` — near-real-time search without excessive refresh overhead
+*
+* @param overrides - Override or extend any setting. Applied after defaults.
+*
+* @example
+* const index = indexBuilder()
+*   .mappings(schema)
+*   .settings(productionSearchSettings())
+*   .build();
+*
+* @example
+* // With best_compression for disk savings
+* productionSearchSettings({ codec: 'best_compression' })
+*
+* @example
+* // Restore production settings after bulk ingest
+* await client.indices.putSettings({
+*   index: 'my-index',
+*   body: productionSearchSettings(),
+* });
+* await client.indices.refresh({ index: 'my-index' });
+*/
+const productionSearchSettings = (overrides) => ({
+	number_of_replicas: 1,
+	refresh_interval: "5s",
+	...overrides
+});
+/**
+* Generate index sort settings from a field→direction (or full spec) map.
+*
+* Index-time sorting improves compression (similar values stored together) and
+* enables early termination when query sort matches index sort. Combine with
+* `trackTotalHits(false)` for fastest sorted queries.
+*
+* The returned object lives at the top level of `IndicesIndexSettings` — spread it
+* directly into a settings object (do NOT wrap it under an `index` key, the
+* `@elastic/elasticsearch` client normalises that form).
+*
+* Pass a bare `'asc' | 'desc'` for simple cases; pass `{ order, mode?, missing? }`
+* when you need `mode` (`min`/`max`/`median`/`avg`) or `missing` (`_first`/`_last`).
+*
+* @param fields - Map of field names to sort direction or full spec.
+* @returns A `{ sort: IndicesIndexSegmentSort }` fragment to spread into your settings.
+*
+* @example
+* const index = indexBuilder()
+*   .mappings(schema)
+*   .settings({
+*     ...productionSearchSettings(),
+*     ...indexSortSettings({ timestamp: 'desc', status: 'asc' }),
+*   })
+*   .build();
+*
+* @example
+* indexSortSettings({
+*   price: { order: 'asc', mode: 'min', missing: '_last' },
+*   created_at: 'desc'
+* })
+*/
+const indexSortSettings = (fields) => {
+	const entries = Object.entries(fields);
+	const normalize = (spec) => typeof spec === "string" ? { order: spec } : spec;
+	const hasAnyMode = entries.some(([, spec]) => typeof spec !== "string" && spec.mode !== void 0);
+	const hasAnyMissing = entries.some(([, spec]) => typeof spec !== "string" && spec.missing !== void 0);
+	return { sort: {
+		field: entries.map(([name]) => name),
+		order: entries.map(([, spec]) => normalize(spec).order),
+		...hasAnyMode && { mode: entries.map(([, spec]) => normalize(spec).mode ?? "min") },
+		...hasAnyMissing && { missing: entries.map(([, spec]) => normalize(spec).missing ?? "_last") }
+	} };
+};
+/**
+* Settings optimized for maximum indexing speed during bulk operations.
+*
+* Apply via the ES `_settings` API before starting bulk ingest, then revert
+* with `productionSearchSettings()` afterward. Do not use these as permanent
+* index settings — they trade durability and search availability for speed.
+*
+* Defaults:
+* - `refresh_interval: '-1'` — disables refresh (can improve reindex time by 70%+)
+* - `number_of_replicas: 0` — no replication overhead during ingest
+* - `translog.durability: 'async'` — async translog for faster writes
+* - `translog.sync_interval: '30s'` — less frequent translog sync
+*
+* @param overrides - Override or extend any setting. Applied after defaults.
+* `translog` overrides are deep-merged so individual translog keys can be
+* changed without clobbering the other defaults.
+*
+* @example
+* // Apply before bulk ingest via ES client
+* await client.indices.putSettings({
+*   index: 'my-index',
+*   body: fastIngestSettings(),
+* });
+*
+* @example
+* // With custom overrides
+* fastIngestSettings({ number_of_shards: 3 })
+*/
+const fastIngestSettings = (overrides) => {
+	const { translog, ...rest } = overrides ?? {};
+	return {
+		number_of_replicas: 0,
+		refresh_interval: "-1",
+		translog: {
+			durability: "async",
+			sync_interval: "30s",
+			...translog
+		},
+		...rest
+	};
+};
+//#endregion
+//#region src/index.ts
+const queryBuilder = (_schema, includeQuery = true) => createQueryBuilder({ _includeQuery: includeQuery });
+/**
+* Type inference helper for vanilla JavaScript.
+*
+* **Type-only — do not use the returned value at runtime.** This function always returns
+* `undefined`; its declared return type is a lie used to carry `Infer<typeof schema>` into
+* JSDoc `@type` annotations. Accessing properties on the return value (e.g. `inferType(s).name`)
+* will throw `TypeError`.
+*
+* @example
+* const schema = mappings({ name: text() });
+* const _Product = inferType(schema); // undefined at runtime; type-only
+*
+* /** @type {typeof _Product} *\/
+* const doc = { name: 'Laptop' };
+*
+* In TypeScript, prefer `type Product = Infer<typeof schema>` directly.
+*/
+const inferType = (_schema) => void 0;
+//#endregion
+exports.aggregations = aggregations;
+exports.alias = alias;
+exports.binary = binary;
+exports.boolean = boolean;
+exports.bulk = bulk;
+exports.byte = byte;
+exports.completion = completion;
+exports.constantKeyword = constantKeyword;
+exports.date = date;
+exports.dateNanos = dateNanos;
+exports.dateRange = dateRange;
+exports.denseVector = denseVector;
+exports.double = double;
+exports.doubleRange = doubleRange;
+exports.fastIngestSettings = fastIngestSettings;
+exports.flattened = flattened;
+exports.float = float;
+exports.floatRange = floatRange;
+exports.geoPoint = geoPoint;
+exports.geoShape = geoShape;
+exports.halfFloat = halfFloat;
+exports.indexBuilder = indexBuilder;
+exports.indexSortSettings = indexSortSettings;
+exports.inferType = inferType;
+exports.integer = integer;
+exports.integerRange = integerRange;
+exports.ip = ip;
+exports.ipRange = ipRange;
+exports.join = join;
+exports.keyword = keyword;
+exports.long = long;
+exports.longRange = longRange;
+exports.mappings = mappings;
+exports.matchOnlyText = matchOnlyText;
+exports.msearch = msearch;
+exports.murmur3Hash = murmur3Hash;
+exports.nested = nested;
+exports.object = object;
+exports.percolator = percolator;
+exports.productionSearchSettings = productionSearchSettings;
+exports.quantizedDenseVector = quantizedDenseVector;
+exports.queryBuilder = queryBuilder;
+exports.rankFeature = rankFeature;
+exports.rankFeatures = rankFeatures;
+exports.scaledFloat = scaledFloat;
+exports.searchAsYouType = searchAsYouType;
+exports.semanticText = semanticText;
+exports.short = short;
+exports.sparseVector = sparseVector;
+exports.suggest = suggest;
+exports.text = text;
+exports.tokenCount = tokenCount;
+exports.unsignedLong = unsignedLong;
+exports.wildcardField = wildcardField;
+
+//# sourceMappingURL=index.cjs.map