elasticlink 0.8.0-beta → 1.0.0-beta.2

package/dist/bulk.builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk.builder.d.ts","sourceRoot":"","sources":["../src/bulk.builder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAS,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAEjC,aAAY,GAAG,EAAO,KACrB,WAAW,CAAC,CAAC,CAiCd,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC;;EAC3C,CAAC"}

package/dist/bulk.builder.js

@@ -1,51 +0,0 @@
-/**
- * Bulk API builder
- * Enables batching multiple index/create/update/delete operations
- */
-/**
- * Creates a bulk operations builder
- * @returns BulkBuilder instance
- */
-export const createBulkBuilder = (
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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, ...header } = meta;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const updateDoc = {
-            ...(doc && { doc }),
-            ...(script && { script }),
-            ...(upsert && { upsert }),
-            ...(doc_as_upsert !== undefined && { doc_as_upsert })
-        };
-        return createBulkBuilder([...operations, { update: header }, updateDoc]);
-    },
-    delete: (meta) => {
-        return createBulkBuilder([...operations, { delete: meta }]);
-    },
-    // eslint-disable-next-line functional/functional-parameters
-    build: () => {
-        return `${operations.map((op) => JSON.stringify(op)).join('\n')}\n`;
-    },
-    // eslint-disable-next-line functional/functional-parameters
-    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
- */
-export const bulk = (_schema) => createBulkBuilder();

package/dist/bulk.types.d.ts

@@ -1,46 +0,0 @@
-/**
- * Type definitions for Bulk API
- * Derived from official @elastic/elasticsearch types for accuracy and completeness.
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-import type { BulkIndexOperation, BulkCreateOperation, BulkUpdateOperation, BulkUpdateAction, BulkDeleteOperation } from '@elastic/elasticsearch/lib/api/types';
-/**
- * Metadata for bulk index operation — re-exported from official @elastic/elasticsearch types
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-export type BulkIndexMeta = BulkIndexOperation;
-/**
- * Metadata for bulk create operation — re-exported from official @elastic/elasticsearch types
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-export type BulkCreateMeta = BulkCreateOperation;
-/**
- * Metadata for bulk update operation.
- * Combines official BulkUpdateOperation (header) with BulkUpdateAction (body) for ergonomic API.
- * The builder splits these into separate header and body when building the bulk request.
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-export type BulkUpdateMeta<T> = BulkUpdateOperation & BulkUpdateAction<T, Partial<T>>;
-/**
- * Metadata for bulk delete operation — re-exported from official @elastic/elasticsearch types
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-export type BulkDeleteMeta = BulkDeleteOperation;
-/**
- * Bulk operations builder interface
- */
-export type BulkBuilder<T> = {
-    /** Index a document (create or replace) */
-    index: (doc: T, meta?: BulkIndexMeta) => BulkBuilder<T>;
-    /** Create a new document (fails if already exists) */
-    create: (doc: T, meta?: BulkCreateMeta) => BulkBuilder<T>;
-    /** Update an existing document */
-    update: (meta: BulkUpdateMeta<T>) => BulkBuilder<T>;
-    /** Delete a document */
-    delete: (meta: BulkDeleteMeta) => BulkBuilder<T>;
-    /** Build as NDJSON string format for Elasticsearch */
-    build: () => string;
-    /** Build as array of objects */
-    buildArray: () => any[];
-};
-//# sourceMappingURL=bulk.types.d.ts.map

package/dist/bulk.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk.types.d.ts","sourceRoot":"","sources":["../src/bulk.types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,mBAAmB,GAAG,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,2CAA2C;IAC3C,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,aAAa,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;IACxD,sDAAsD;IACtD,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;IAC1D,kCAAkC;IAClC,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;IACpD,wBAAwB;IACxB,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;IACjD,sDAAsD;IACtD,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,gCAAgC;IAEhC,UAAU,EAAE,MAAM,GAAG,EAAE,CAAC;CACzB,CAAC"}

package/dist/bulk.types.js

@@ -1,6 +0,0 @@
-/**
- * Type definitions for Bulk API
- * Derived from official @elastic/elasticsearch types for accuracy and completeness.
- * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
- */
-export {};

package/dist/field.helpers.d.ts

@@ -1,167 +0,0 @@
-/**
- * Field type helper functions for ergonomic index mapping definitions.
- * Each helper returns a narrowly-typed mapping with a literal `type` field,
- * enabling compile-time field-type inference in the query builder.
- *
- * @example
- * import { text, keyword, denseVector, mappings } from 'elasticlink';
- *
- * const productMappings = mappings({
- *   name: text({ analyzer: 'standard' }),
- *   price: float(),
- *   category: keyword(),
- *   embedding: denseVector({ dims: 384 }),
- * });
- */
-import type { TextFieldOptions, KeywordFieldOptions, NumericFieldOptions, UnsignedLongFieldOptions, ScaledFloatFieldOptions, DateFieldOptions, BooleanFieldOptions, DenseVectorFieldOptions, SemanticTextFieldOptions, ObjectFieldOptions, CompletionFieldOptions, GeoPointFieldOptions, GeoShapeFieldOptions, AliasFieldOptions, IpFieldOptions, RangeFieldOptions, MatchOnlyTextFieldOptions, SearchAsYouTypeFieldOptions, ConstantKeywordFieldOptions, WildcardFieldOptions, FlattenedFieldOptions, FieldMappingWithLiteralType, TextFieldMapping, KeywordFieldMapping, LongFieldMapping, IntegerFieldMapping, ShortFieldMapping, ByteFieldMapping, DoubleFieldMapping, FloatFieldMapping, HalfFloatFieldMapping, ScaledFloatFieldMapping, DateFieldMapping, BooleanFieldMapping, BinaryFieldMapping, IpFieldMapping, DenseVectorFieldMapping, SparseVectorFieldMapping, SemanticTextFieldMapping, UnsignedLongFieldMapping, GeoPointFieldMapping, GeoShapeFieldMapping, CompletionFieldMapping, TypedNestedFieldMapping, TypedObjectFieldMapping, AliasFieldMapping, PercolatorFieldMapping, IntegerRangeFieldMapping, FloatRangeFieldMapping, LongRangeFieldMapping, DoubleRangeFieldMapping, DateRangeFieldMapping, MatchOnlyTextFieldMapping, SearchAsYouTypeFieldMapping, ConstantKeywordFieldMapping, WildcardFieldMapping, FlattenedFieldMapping } from './field.types.js';
-export declare const text: (options?: TextFieldOptions) => TextFieldMapping;
-export declare const keyword: (options?: KeywordFieldOptions) => KeywordFieldMapping;
-export declare const long: (options?: NumericFieldOptions) => LongFieldMapping;
-export declare const integer: (options?: NumericFieldOptions) => IntegerFieldMapping;
-export declare const short: (options?: NumericFieldOptions) => ShortFieldMapping;
-export declare const byte: (options?: NumericFieldOptions) => ByteFieldMapping;
-export declare const double: (options?: NumericFieldOptions) => DoubleFieldMapping;
-export declare const float: (options?: NumericFieldOptions) => FloatFieldMapping;
-export declare const halfFloat: (options?: NumericFieldOptions) => HalfFloatFieldMapping;
-export declare const scaledFloat: (options?: ScaledFloatFieldOptions) => ScaledFloatFieldMapping;
-export declare const date: (options?: DateFieldOptions) => DateFieldMapping;
-export declare const boolean: (options?: BooleanFieldOptions) => BooleanFieldMapping;
-export declare const binary: () => BinaryFieldMapping;
-export declare const ip: (options?: IpFieldOptions) => IpFieldMapping;
-export declare const denseVector: (options?: DenseVectorFieldOptions) => DenseVectorFieldMapping;
-/**
- * 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 = query(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();
- */
-export declare const quantizedDenseVector: (options?: DenseVectorFieldOptions) => DenseVectorFieldMapping;
-/**
- * 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
- */
-export declare const sparseVector: () => SparseVectorFieldMapping;
-/**
- * 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
- */
-export declare const semanticText: (options?: SemanticTextFieldOptions) => SemanticTextFieldMapping;
-/**
- * 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
- */
-export declare const unsignedLong: (options?: UnsignedLongFieldOptions) => UnsignedLongFieldMapping;
-export declare const geoPoint: (options?: GeoPointFieldOptions) => GeoPointFieldMapping;
-export declare const geoShape: (options?: GeoShapeFieldOptions) => GeoShapeFieldMapping;
-export declare const completion: (options?: CompletionFieldOptions) => CompletionFieldMapping;
-/**
- * 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(),
- *   }),
- * });
- * query(m).term('address.city', 'NYC').build();
- */
-export declare function object<F extends Record<string, FieldMappingWithLiteralType>>(fields: F, options?: ObjectFieldOptions): TypedObjectFieldMapping<F>;
-/**
- * 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(),
- *   }),
- * });
- * query(m).nested('tags', q => q.term('label', 'sale')).build();
- */
-export declare function nested<F extends Record<string, FieldMappingWithLiteralType>>(fields: F): TypedNestedFieldMapping<F>;
-export declare const alias: (options: AliasFieldOptions) => AliasFieldMapping;
-export declare const percolator: () => PercolatorFieldMapping;
-export declare const integerRange: (options?: RangeFieldOptions) => IntegerRangeFieldMapping;
-export declare const floatRange: (options?: RangeFieldOptions) => FloatRangeFieldMapping;
-export declare const longRange: (options?: RangeFieldOptions) => LongRangeFieldMapping;
-export declare const doubleRange: (options?: RangeFieldOptions) => DoubleRangeFieldMapping;
-export declare const dateRange: (options?: RangeFieldOptions) => DateRangeFieldMapping;
-/**
- * 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).
- */
-export declare const matchOnlyText: (options?: MatchOnlyTextFieldOptions) => MatchOnlyTextFieldMapping;
-/**
- * Autocomplete / typeahead field. Creates sub-fields for edge n-gram matching
- * out of the box. Query with `multi_match` targeting the generated sub-fields.
- */
-export declare const searchAsYouType: (options?: SearchAsYouTypeFieldOptions) => SearchAsYouTypeFieldMapping;
-/**
- * Field where every document has the same value. Useful for multi-index queries
- * to identify the index type (e.g., `constantKeyword({ value: 'product' })`).
- */
-export declare const constantKeyword: (options?: ConstantKeywordFieldOptions) => ConstantKeywordFieldMapping;
-/**
- * Optimized for grep-like wildcard/regexp queries on high-cardinality or large fields.
- * Use instead of `keyword()` when leading wildcards (`*foo`) are needed.
- */
-export declare const wildcardField: (options?: WildcardFieldOptions) => WildcardFieldMapping;
-/**
- * Flattens complex/dynamic objects into a single field. Faster than `nested()`,
- * but only supports keyword-level queries on inner values.
- */
-export declare const flattened: (options?: FlattenedFieldOptions) => FlattenedFieldMapping;
-//# sourceMappingURL=field.helpers.d.ts.map

package/dist/field.helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"field.helpers.d.ts","sourceRoot":"","sources":["../src/field.helpers.ts"],"names":[],"mappings":"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"}

package/dist/field.helpers.js

@@ -1,282 +0,0 @@
-/**
- * Field type helper functions for ergonomic index mapping definitions.
- * Each helper returns a narrowly-typed mapping with a literal `type` field,
- * enabling compile-time field-type inference in the query builder.
- *
- * @example
- * import { text, keyword, denseVector, mappings } from 'elasticlink';
- *
- * const productMappings = mappings({
- *   name: text({ analyzer: 'standard' }),
- *   price: float(),
- *   category: keyword(),
- *   embedding: denseVector({ dims: 384 }),
- * });
- */
-// Text & keyword
-export const text = (options) => ({
-    type: 'text',
-    ...options
-});
-export const keyword = (options) => ({
-    type: 'keyword',
-    ...options
-});
-// Numeric
-export const long = (options) => ({
-    type: 'long',
-    ...options
-});
-export const integer = (options) => ({
-    type: 'integer',
-    ...options
-});
-export const short = (options) => ({
-    type: 'short',
-    ...options
-});
-export const byte = (options) => ({
-    type: 'byte',
-    ...options
-});
-export const double = (options) => ({
-    type: 'double',
-    ...options
-});
-export const float = (options) => ({
-    type: 'float',
-    ...options
-});
-export const halfFloat = (options) => ({
-    type: 'half_float',
-    ...options
-});
-export const scaledFloat = (options) => ({
-    type: 'scaled_float',
-    ...options
-});
-// Date & boolean
-export const date = (options) => ({
-    type: 'date',
-    ...options
-});
-export const boolean = (options) => ({
-    type: 'boolean',
-    ...options
-});
-// Binary
-// eslint-disable-next-line functional/functional-parameters
-export const binary = () => ({ type: 'binary' });
-// IP
-export const ip = (options) => ({
-    type: 'ip',
-    ...options
-});
-// Vector
-export 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 = query(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();
- */
-export 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
- */
-// eslint-disable-next-line functional/functional-parameters
-export const sparseVector = () => ({ type: 'sparse_vector' });
-/**
- * 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
- */
-export 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
- */
-export const unsignedLong = (options) => ({
-    type: 'unsigned_long',
-    ...options
-});
-// Geo
-export const geoPoint = (options) => ({
-    type: 'geo_point',
-    ...options
-});
-export const geoShape = (options) => ({
-    type: 'geo_shape',
-    ...options
-});
-// Completion
-export const completion = (options) => ({
-    type: 'completion',
-    ...options
-});
-// Structured
-/**
- * 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(),
- *   }),
- * });
- * query(m).term('address.city', 'NYC').build();
- */
-export function object(fields, options) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    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(),
- *   }),
- * });
- * query(m).nested('tags', q => q.term('label', 'sale')).build();
- */
-export function nested(fields) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return { type: 'nested', properties: fields };
-}
-// Alias
-export const alias = (options) => ({
-    type: 'alias',
-    ...options
-});
-// Percolator
-// eslint-disable-next-line functional/functional-parameters
-export const percolator = () => ({
-    type: 'percolator'
-});
-// Range types
-export const integerRange = (options) => ({
-    type: 'integer_range',
-    ...options
-});
-export const floatRange = (options) => ({
-    type: 'float_range',
-    ...options
-});
-export const longRange = (options) => ({
-    type: 'long_range',
-    ...options
-});
-export const doubleRange = (options) => ({
-    type: 'double_range',
-    ...options
-});
-export const dateRange = (options) => ({
-    type: 'date_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).
- */
-export 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.
- */
-export 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' })`).
- */
-export 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.
- */
-export 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.
- */
-export const flattened = (options) => ({
-    type: 'flattened',
-    ...options
-});