@elastic/esql 0.0.1

package/lib/composer/esql.d.ts

@@ -0,0 +1,25 @@
+import type { ComposerQueryGenerator, ComposerQueryTag, ComposerQueryTagMethods, ParametrizedComposerQueryTag } from './types';
+/**
+ * ESQL query composer tag function.
+ *
+ * This function allows you to create ESQL queries using template literals.
+ * It supports both static and dynamic inputs, but it is designed to provide
+ * safe and structured query construction with dynamic parameters.
+ *
+ * Basic example:
+ *
+ * ```typescript
+ * const inputFromUser = 42;
+ * const query = esql`FROM index | WHERE foo > ${inputFromUser} | LIMIT 10`;
+ * ```
+ *
+ * @param templateOrQuery The ESQL query template or a string representing the query.
+ * @param holes The dynamic values to be interpolated into the query.
+ * @returns A ComposerQuery instance representing the constructed ESQL query.
+ */
+export declare const esql: ComposerQueryTag & ParametrizedComposerQueryTag & ComposerQueryGenerator & ComposerQueryTagMethods;
+/**
+ * Alias for {@link esql} for convenience.
+ */
+export declare const e: ComposerQueryTag & ParametrizedComposerQueryTag & ComposerQueryGenerator & ComposerQueryTagMethods;
+//# sourceMappingURL=esql.d.ts.map

package/lib/composer/esql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esql.d.ts","sourceRoot":"","sources":["../../src/composer/esql.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAEV,sBAAsB,EACtB,gBAAgB,EAEhB,uBAAuB,EAIvB,4BAA4B,EAC7B,MAAM,SAAS,CAAC;AA8JjB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,EAAE,gBAAgB,GACjC,4BAA4B,GAC5B,sBAAsB,GACtB,uBAmCD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,CAAC,oGAAO,CAAC"}

package/lib/composer/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './types';
+export { esql, e } from './esql';
+export { ComposerQuery } from './composer_query';
+export { ParameterHole } from './parameter_hole';
+export * as synth from './synth';
+export { qry, cmd, exp } from './synth';
+export { EsqlQuery } from './query';
+//# sourceMappingURL=index.d.ts.map

package/lib/composer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composer/index.ts"],"names":[],"mappings":"AAOA,mBAAmB,SAAS,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/lib/composer/parameter_hole.d.ts

@@ -0,0 +1,11 @@
+export declare class ParameterHole {
+    value: unknown;
+    name?: string | undefined;
+    constructor(value: unknown, name?: string | undefined);
+}
+export declare class DoubleParameterHole {
+    value: unknown;
+    name?: string | undefined;
+    constructor(value: unknown, name?: string | undefined);
+}
+//# sourceMappingURL=parameter_hole.d.ts.map

package/lib/composer/parameter_hole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter_hole.d.ts","sourceRoot":"","sources":["../../src/composer/parameter_hole.ts"],"names":[],"mappings":"AAOA,qBAAa,aAAa;IAEf,KAAK,EAAE,OAAO;IACd,IAAI,CAAC,EAAE,MAAM;gBADb,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,MAAM,YAAA;CAEvB;AAED,qBAAa,mBAAmB;IAErB,KAAK,EAAE,OAAO;IACd,IAAI,CAAC,EAAE,MAAM;gBADb,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,MAAM,YAAA;CAEvB"}

package/lib/composer/query/index.d.ts

@@ -0,0 +1,2 @@
+export { EsqlQuery } from './query';
+//# sourceMappingURL=index.d.ts.map

package/lib/composer/query/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composer/query/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/lib/composer/query/query.d.ts

@@ -0,0 +1,54 @@
+import type { Token } from 'antlr4';
+import type { ParseOptions } from '../../parser';
+import type { ESQLAstQueryExpression, EditorError } from '../../types';
+import type { WrappingPrettyPrinterOptions } from '../../pretty_print/wrapping_pretty_printer';
+/**
+ * Represents a parsed or programmatically created ES|QL query. Keeps track of
+ * the AST, source code, and optionally lexer tokens.
+ */
+export declare class EsqlQuery {
+    /**
+     * The parsed or programmatically created ES|QL AST. The AST is the only
+     * required property for the query and is the source of truth for the query.
+     */
+    readonly ast: ESQLAstQueryExpression;
+    /**
+     * Optional source code that was used to generate the AST. Provide this
+     * if the query was created from a parsed source code. Otherwise, set to
+     * an empty string.
+     */
+    readonly src: string;
+    /**
+     * Optional array of ANTLR tokens, in case the query was parsed from
+     * source text.
+     */
+    readonly tokens: Token[];
+    /**
+     * Parsing errors.
+     */
+    readonly errors: EditorError[];
+    static readonly fromSrc: (src: string, opts?: ParseOptions) => EsqlQuery;
+    constructor(
+    /**
+     * The parsed or programmatically created ES|QL AST. The AST is the only
+     * required property for the query and is the source of truth for the query.
+     */
+    ast: ESQLAstQueryExpression, 
+    /**
+     * Optional source code that was used to generate the AST. Provide this
+     * if the query was created from a parsed source code. Otherwise, set to
+     * an empty string.
+     */
+    src?: string, 
+    /**
+     * Optional array of ANTLR tokens, in case the query was parsed from
+     * source text.
+     */
+    tokens?: Token[], 
+    /**
+     * Parsing errors.
+     */
+    errors?: EditorError[]);
+    print(opts?: WrappingPrettyPrinterOptions): string;
+}
+//# sourceMappingURL=query.d.ts.map

package/lib/composer/query/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/composer/query/query.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAG/F;;;GAGG;AACH,qBAAa,SAAS;IAQlB;;;OAGG;aACa,GAAG,EAAE,sBAAsB;IAE3C;;;;OAIG;aACa,GAAG,EAAE,MAAM;IAE3B;;;OAGG;aACa,MAAM,EAAE,KAAK,EAAE;IAE/B;;OAEG;aACa,MAAM,EAAE,WAAW,EAAE;IA7BvC,gBAAuB,OAAO,GAAI,KAAK,MAAM,EAAE,OAAO,YAAY,KAAG,SAAS,CAI5E;;IAGA;;;OAGG;IACa,GAAG,EAAE,sBAAsB;IAE3C;;;;OAIG;IACa,GAAG,GAAE,MAAW;IAEhC;;;OAGG;IACa,MAAM,GAAE,KAAK,EAAO;IAEpC;;OAEG;IACa,MAAM,GAAE,WAAW,EAAO;IAGrC,KAAK,CAAC,IAAI,CAAC,EAAE,4BAA4B,GAAG,MAAM;CAI1D"}

package/lib/composer/synth/command.d.ts

@@ -0,0 +1,7 @@
+import type { ESQLCommand } from '../../types';
+export declare const command: import("./types").SynthMethod<ESQLCommand<string>>;
+/**
+ * Short 3-letter alias for DX convenience.
+ */
+export declare const cmd: import("./types").SynthMethod<ESQLCommand<string>>;
+//# sourceMappingURL=command.d.ts.map

package/lib/composer/synth/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/command.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmB/C,eAAO,MAAM,OAAO,oDAAoC,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,GAAG,oDAAU,CAAC"}

package/lib/composer/synth/expression.d.ts

@@ -0,0 +1,6 @@
+export declare const expression: import("./types").SynthMethod<import("../../types").ESQLSingleAstItem>;
+/**
+ * Short 3-letter alias for DX convenience.
+ */
+export declare const exp: import("./types").SynthMethod<import("../../types").ESQLSingleAstItem>;
+//# sourceMappingURL=expression.d.ts.map

package/lib/composer/synth/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/expression.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,UAAU,wEAA0C,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,GAAG,wEAAa,CAAC"}

package/lib/composer/synth/header.d.ts

@@ -0,0 +1,7 @@
+import type { ESQLAstHeaderCommand } from '../../types';
+export declare const header: import("./types").SynthMethod<ESQLAstHeaderCommand<string, import("../../types").ESQLSingleAstItem>>;
+/**
+ * Short 3-letter alias for DX convenience.
+ */
+export declare const hdr: import("./types").SynthMethod<ESQLAstHeaderCommand<string, import("../../types").ESQLSingleAstItem>>;
+//# sourceMappingURL=header.d.ts.map

package/lib/composer/synth/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/header.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAiBxD,eAAO,MAAM,MAAM,sGAA6C,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,GAAG,sGAAS,CAAC"}

package/lib/composer/synth/holes.d.ts

@@ -0,0 +1,27 @@
+import type { SynthQualifiedColumnShorthand, SynthTemplateHole } from './types';
+/**
+ * Identifies qualified column shorthand tuples.
+ * ['qualifier', ['fieldName']]
+ * ['qualifier', ['fieldPart1', 'fieldPart2']]
+ * @param hole
+ * @returns
+ */
+export declare const isQualifiedColumnShorthand: (hole: unknown) => hole is SynthQualifiedColumnShorthand;
+/**
+ * Converts a synth template hole to a string fragment. A *hole" in a tagged
+ * template is JavaScript value, which is returned as-is, during the template
+ * execution:
+ *
+ * ```js
+ * tag `SELECT * FROM table WHERE id = ${hole}`;
+ * ```
+ *
+ * In the above example, the `hole` value is fed into the `tag` function as-is
+ * (it is not converted to a string). This function is used to convert the
+ * hole to a string fragment, which can be used in the query string.
+ *
+ * @param hole The hole to convert to a string fragment.
+ * @returns A string representation of the hole.
+ */
+export declare const holeToFragment: (hole: SynthTemplateHole) => string;
+//# sourceMappingURL=holes.d.ts.map

package/lib/composer/synth/holes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"holes.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/holes.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAEV,6BAA6B,EAC7B,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAYjB;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACrC,MAAM,OAAO,KACZ,IAAI,IAAI,6BAOV,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,iBAAiB,KAAG,MAyDxD,CAAC"}

package/lib/composer/synth/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './types';
+export { exp, expression } from './expression';
+export { cmd, command } from './command';
+export { qry, query } from './query';
+export { hdr, header } from './header';
+export * from './nodes';
+//# sourceMappingURL=index.d.ts.map

package/lib/composer/synth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/index.ts"],"names":[],"mappings":"AAOA,mBAAmB,SAAS,CAAC;AAC7B,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,cAAc,SAAS,CAAC"}

package/lib/composer/synth/nodes.d.ts

@@ -0,0 +1,104 @@
+import type { ESQLColumn, ESQLDecimalLiteral, ESQLFunction, ESQLIntegerLiteral, ESQLList, ESQLParamLiteral, ESQLSource, ESQLStringLiteral } from '../../types';
+import { SynthLiteralFragment } from './synth_literal_fragment';
+import { SynthNode } from './synth_node';
+import type { SynthColumnShorthand, SynthQualifiedColumnShorthand } from './types';
+/**
+ * Creates an ES|QL source node.
+ *
+ * @param index Elasticsearch index name to create a source node for.
+ * @returns ES|QL source node.
+ */
+export declare const src: (index: string, prefix?: string, selector?: string) => ESQLSource;
+/**
+ * Creates an ES|QL source node with an alias (e.g., `index AS alias`).
+ *
+ * @param index Elasticsearch index name to create a source node for.
+ * @param alias The alias name for the source.
+ * @returns ES|QL binary expression node representing `source AS alias`.
+ */
+export declare const srcAs: (index: string, alias: string) => ESQLFunction<"binary-expression", "as">;
+/**
+ * Crates an ES|QL integer literal node.
+ *
+ * @param value The integer value to create a literal for.
+ * @returns ES|QL integer literal node.
+ */
+export declare const int: (value: number) => ESQLIntegerLiteral;
+/**
+ * Creates an ES|QL decimal (float, double) literal node.
+ *
+ * @param value The decimal value to create a literal for.
+ * @returns ES|QL decimal literal node.
+ */
+export declare const float: (value: number) => ESQLDecimalLiteral;
+/**
+ * Creates an ES|QL numeric literal node. If the value is an integer, an integer
+ * literal node is created, otherwise a decimal literal node is created.
+ *
+ * @param value The numeric value to create a literal for.
+ * @returns ES|QL numeric literal node.
+ */
+export declare const num: (value: number) => ESQLDecimalLiteral | ESQLIntegerLiteral;
+/**
+ * Creates an ES|QL boolean literal node.
+ *
+ * @param value The boolean value to create a literal for.
+ * @returns ES|QL boolean literal node.
+ */
+export declare const bool: (value: boolean) => import("../../types").ESQLBooleanLiteral & SynthNode;
+/**
+ * Creates an ES|QL string literal node.
+ *
+ * @param value The string value to create a literal for.
+ * @returns ES|QL string literal node.
+ */
+export declare const str: (value: string) => ESQLStringLiteral;
+/**
+ * Creates an ES|QL named parameter node.
+ *
+ * @param name The name of the parameter.
+ * @returns ES|QL named parameter node.
+ */
+export declare const par: (name: string) => ESQLParamLiteral;
+/**
+ * Creates an ES|QL named double parameter node.
+ *
+ * @param name The name of the parameter.
+ * @returns ES|QL named parameter node.
+ */
+export declare const dpar: (name: string) => ESQLParamLiteral;
+/**
+ * Creates an ES|QL column node.
+ *
+ * @param name The name of the column.
+ * @returns ES|QL column node.
+ */
+export declare const col: (name: string | SynthColumnShorthand | SynthQualifiedColumnShorthand) => ESQLColumn;
+/**
+ * Creates a literal fragment representing a keyword.
+ *
+ * @param keyword The keyword to create a literal fragment for.
+ * @returns A SynthLiteralFragment representing the keyword.
+ */
+export declare const kwd: (keyword: string) => SynthLiteralFragment;
+/**
+ * Supported primitive types for ES|QL list literals.
+ */
+export type ListPrimitive = string | number | boolean;
+/**
+ * Creates an ES|QL list literal AST node from an array of primitive values.
+ *
+ * The array elements must all be of the same primitive type: string, number,
+ * or boolean. ES|QL list literals use square brackets and are rendered as:
+ *
+ * - `[1, 2, 3]` for integer lists
+ * - `["a", "b"]` for string lists
+ * - `[TRUE, FALSE]` for boolean lists
+ *
+ * @param values An array of primitive values (strings, numbers, or booleans).
+ *     All elements must be of the same type.
+ * @returns ES|QL list literal node.
+ * @throws Error if the array is empty or contains unsupported types.
+ */
+export declare const list: (values: ListPrimitive[]) => ESQLList;
+//# sourceMappingURL=nodes.d.ts.map

package/lib/composer/synth/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/nodes.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAEnF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,WAAW,MAAM,KAAG,UAIvE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAM1F,CAAC;AACF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,kBAInC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,KAAG,kBAIrC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,kBAAkB,GAAG,kBAMxD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,OAAO,yDAIlC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,iBAInC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,KAAG,gBAIlC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,gBAInC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GACd,MAAM,MAAM,GAAG,oBAAoB,GAAG,6BAA6B,KAClE,UAgBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,oBAErC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,GAAI,QAAQ,aAAa,EAAE,KAAG,QAmC9C,CAAC"}

package/lib/composer/synth/query.d.ts

@@ -0,0 +1,7 @@
+import type { ESQLAstQueryExpression } from '../../types';
+export declare const query: import("./types").SynthMethod<ESQLAstQueryExpression>;
+/**
+ * Short 3-letter alias for DX convenience.
+ */
+export declare const qry: import("./types").SynthMethod<ESQLAstQueryExpression>;
+//# sourceMappingURL=query.d.ts.map

package/lib/composer/synth/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/query.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAyC1D,eAAO,MAAM,KAAK,uDAA+C,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,GAAG,uDAAQ,CAAC"}

package/lib/composer/synth/synth_literal_fragment.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A simple wrapper class to represent a literal string fragment in the Synth
+ * API. This is used to represent string fragments that are not parsed into
+ * proper AST nodes, but are still valid parts of the query string. Caution
+ * needed when using this, as this allows to insert arbitrary strings into
+ * the query, the intended use is for conditionally inserting command names or
+ * other keywords.
+ *
+ * For example, a literal fragment can be used to insert a raw ES|QL keyword:
+ *
+ * ```ts
+ * synth.cmd `SORT a NULLS ${ new SynthLiteralFragment('FIRST') }`
+ * ```
+ */
+export declare class SynthLiteralFragment {
+    readonly value: string;
+    constructor(value: string);
+}
+//# sourceMappingURL=synth_literal_fragment.d.ts.map

package/lib/composer/synth/synth_literal_fragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth_literal_fragment.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/synth_literal_fragment.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAoB;aACH,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CAC1C"}

package/lib/composer/synth/synth_node.d.ts

@@ -0,0 +1,19 @@
+import { type PrintAstOptions } from '../../debug';
+import type { ESQLProperNode } from '../../types';
+/**
+ * This is used as a prototype of AST nodes created by the synth methods.
+ * It implements the `toString` method, which is invoked when the node is
+ * coerced to a string. So you can easily convert the node to a string by
+ * calling `String(node)` or `${node}`:
+ *
+ * ```js
+ * const node = expr`a.b`;  // { type: 'column', name: 'a.b' }
+ * String(node)             // 'a.b'
+ * ```
+ */
+export declare class SynthNode {
+    static from<N extends ESQLProperNode>(node: N): N & SynthNode;
+    toString(this: ESQLProperNode): string;
+    dump(this: ESQLProperNode, options?: PrintAstOptions): string;
+}
+//# sourceMappingURL=synth_node.d.ts.map

package/lib/composer/synth/synth_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth_node.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/synth_node.ts"],"names":[],"mappings":"AAUA,OAAO,EAAY,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;GAUG;AACH,qBAAa,SAAS;WACN,IAAI,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAapE,QAAQ,CAAC,IAAI,EAAE,cAAc;IAI7B,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,eAAe;CAGrD"}

package/lib/composer/synth/tag.d.ts

@@ -0,0 +1,4 @@
+import type { ESQLProperNode } from '../../types';
+import type { SynthGenerator, SynthMethod } from './types';
+export declare const createTag: <N extends ESQLProperNode>(generator: SynthGenerator<N>) => SynthMethod<N>;
+//# sourceMappingURL=tag.d.ts.map

package/lib/composer/synth/tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/tag.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EAGZ,MAAM,SAAS,CAAC;AAGjB,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,cAAc,EAChD,WAAW,cAAc,CAAC,CAAC,CAAC,KAC3B,WAAW,CAAC,CAAC,CAyDf,CAAC"}

package/lib/composer/synth/types.d.ts

@@ -0,0 +1,65 @@
+import type { ParseOptions } from '../../parser';
+import type { ESQLAstExpression, ESQLProperNode } from '../../types';
+import type { SynthLiteralFragment } from './synth_literal_fragment';
+import type { SynthNode } from './synth_node';
+export type SynthGenerator<N extends ESQLProperNode> = (src: string, opts?: ParseOptions) => N;
+export type SynthTemplateHole = 
+/**
+ * A hole is normally an AST node.
+ */
+ESQLAstExpression
+/**
+ * If a list of AST nodes is provided, it will be joined with a comma.
+ */
+ | ESQLAstExpression[]
+/**
+ * A shorthand for a column name, which is an array of column parts.
+ */
+ | SynthColumnShorthand
+/**
+ * A shorthand for a qualified column name, which is a tuple where
+ * the first element is the qualifier (e.g., index name) and the second
+ * element is the column name represented as a `SynthColumnShorthand`.
+ */
+ | SynthQualifiedColumnShorthand
+/**
+ * If a number is provided, it will be converted to the right AST node type:
+ *
+ * - integer for integers
+ * - decimal for floats
+ */
+ | number
+/**
+ * A string will be converted to a string literal AST node.
+ */
+ | string
+/**
+ * A boolean will be converted to a boolean literal (TRUE/FALSE) AST node.
+ */
+ | boolean
+/**
+ * A literal fragment can be used to insert raw strings into the query.
+ * Use it for inserting keywords or other query elements that are "smaller"
+ * than a full AST node.
+ */
+ | SynthLiteralFragment;
+/**
+ * A developer-friendly way to specify nested column names in ESQL queries.
+ * Each part in the array represents a segment of the column name.
+ *
+ * For example, `['user', 'name']` represents the column `user.name`.
+ */
+export type SynthColumnShorthand = string[];
+/**
+ * A developer-friendly way to specify qualified column names in ESQL queries.
+ * The first element in the tuple is the qualifier (e.g., index name), and the
+ * second element is the column name represented as a `SynthColumnShorthand`.
+ *
+ * For example, `['index', ['user', 'name']]` represents the column
+ * `[index].[user.name]`.
+ */
+export type SynthQualifiedColumnShorthand = [string, SynthColumnShorthand];
+export type SynthTaggedTemplate<N extends ESQLProperNode> = (template: TemplateStringsArray, ...params: SynthTemplateHole[]) => N & SynthNode;
+export type SynthTaggedTemplateWithOpts<N extends ESQLProperNode> = (opts?: ParseOptions) => SynthTaggedTemplate<N>;
+export type SynthMethod<N extends ESQLProperNode> = SynthGenerator<N> & SynthTaggedTemplate<N> & SynthTaggedTemplateWithOpts<N>;
+//# sourceMappingURL=types.d.ts.map

package/lib/composer/synth/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/composer/synth/types.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,CAAC,CAAC;AAE/F,MAAM,MAAM,iBAAiB;AAC3B;;GAEG;AACD,iBAAiB;AAEnB;;GAEG;GACD,iBAAiB,EAAE;AAErB;;GAEG;GACD,oBAAoB;AAEtB;;;;GAIG;GACD,6BAA6B;AAE/B;;;;;GAKG;GACD,MAAM;AAER;;GAEG;GACD,MAAM;AAER;;GAEG;GACD,OAAO;AAET;;;;GAIG;GACD,oBAAoB,CAAC;AAEzB;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,EAAE,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE3E,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,cAAc,IAAI,CAC1D,QAAQ,EAAE,oBAAoB,EAC9B,GAAG,MAAM,EAAE,iBAAiB,EAAE,KAC3B,CAAC,GAAG,SAAS,CAAC;AAEnB,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,cAAc,IAAI,CAClE,IAAI,CAAC,EAAE,YAAY,KAChB,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE5B,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,cAAc,IAAI,cAAc,CAAC,CAAC,CAAC,GACnE,mBAAmB,CAAC,CAAC,CAAC,GACtB,2BAA2B,CAAC,CAAC,CAAC,CAAC"}