@elastic/esql 0.0.1

package/lib/ast/mutate/commands/from/metadata.d.ts

@@ -0,0 +1,63 @@
+import type { ESQLAstQueryExpression, ESQLColumn, ESQLCommand, ESQLCommandOption } from '../../../../types';
+import type { Predicate } from '../../types';
+/**
+ * Returns all METADATA field AST nodes and their corresponding parent command
+ * option nodes.
+ *
+ * @param ast The root AST node to search for metadata fields.
+ * @returns A collection of [column, option] pairs for each metadata field found.
+ */
+export declare const list: (ast: ESQLAstQueryExpression | ESQLCommand<"from">) => IterableIterator<[ESQLColumn, ESQLCommandOption]>;
+/**
+ * Find a METADATA field by its name or parts.
+ *
+ * @param ast The root AST node to search for metadata fields.
+ * @param fieldName The name or parts of the field to find.
+ * @returns A 2-tuple containing the column and the option it was found in, or
+ *     `undefined` if the field was not found.
+ */
+export declare const find: (ast: ESQLAstQueryExpression, fieldName: string | string[]) => [ESQLColumn, ESQLCommandOption] | undefined;
+/**
+ * Removes the first found METADATA field that satisfies the predicate.
+ *
+ * @param ast The root AST node to search for metadata fields.
+ * @param predicate The predicate function to filter fields.
+ * @returns The removed column and option, if any.
+ */
+export declare const removeByPredicate: (ast: ESQLAstQueryExpression, predicate: Predicate<ESQLColumn>) => [column: ESQLColumn, option: ESQLCommandOption] | undefined;
+/**
+ * Removes the first METADATA field that matches the given name and returns
+ * a 2-tuple (the column and the option it was removed from).
+ *
+ * @param ast The root AST node to search for metadata fields.
+ * @param fieldName The name or parts of the field to remove.
+ * @returns The removed column and option, if any.
+ */
+export declare const remove: (ast: ESQLAstQueryExpression, fieldName: string | string[]) => [column: ESQLColumn, option: ESQLCommandOption] | undefined;
+/**
+ * Insert into a specific position or append a `METADATA` field to the `FROM`
+ * command.
+ *
+ * @param ast The root AST node.
+ * @param fieldName Field name or parts as an array, e.g. `['a', 'b']`.
+ * @param index Position to insert the field at. If `-1` or not specified, the
+ *     field will be appended.
+ * @returns If the field was successfully inserted, returns a 2-tuple containing
+ *     the column and the option it was inserted into. Otherwise, returns
+ *    `undefined`.
+ */
+export declare const insert: (ast: ESQLAstQueryExpression, fieldName: string | string[], index?: number) => [column: ESQLColumn, option: ESQLCommandOption] | undefined;
+/**
+ * The `.upsert()` method works like `.insert()`, but will not insert a field
+ * if it already exists.
+ *
+ * @param ast The root AST node.
+ * @param fieldName The field name or parts as an array, e.g. `['a', 'b']`.
+ * @param index Position to insert the field at. If `-1` or not specified, the
+ *     field will be appended.
+ * @returns If the field was successfully inserted, returns a 2-tuple containing
+ *     the column and the option it was inserted into. Otherwise, returns
+ *    `undefined`.
+ */
+export declare const upsert: (ast: ESQLAstQueryExpression, fieldName: string | string[], index?: number) => [column: ESQLColumn, option: ESQLCommandOption] | undefined;
+//# sourceMappingURL=metadata.d.ts.map

package/lib/ast/mutate/commands/from/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/from/metadata.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EACV,WAAW,EACX,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,GAAG,WAAW,CAAC,MAAM,CAAC,KAChD,gBAAgB,CAAC,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAoClD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,WAAW,MAAM,GAAG,MAAM,EAAE,KAC3B,CAAC,UAAU,EAAE,iBAAiB,CAAC,GAAG,SAYpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,KAAK,sBAAsB,EAC3B,WAAW,SAAS,CAAC,UAAU,CAAC,KAC/B,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAqBpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,WAAW,MAAM,GAAG,MAAM,EAAE,KAC3B,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAWpD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,WAAW,MAAM,GAAG,MAAM,EAAE,EAC5B,QAAO,MAAW,KACjB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAwBpD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,WAAW,MAAM,GAAG,MAAM,EAAE,EAC5B,QAAO,MAAW,KACjB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAoBpD,CAAC"}

package/lib/ast/mutate/commands/from/sources.d.ts

@@ -0,0 +1,9 @@
+import type { ESQLAstQueryExpression, ESQLCommand, ESQLSource } from '../../../../types';
+import type { Predicate } from '../../types';
+export declare const list: (ast: ESQLAstQueryExpression | ESQLCommand<"from">) => IterableIterator<ESQLSource>;
+export declare const findByPredicate: (ast: ESQLAstQueryExpression, predicate: Predicate<ESQLSource>) => ESQLSource | undefined;
+export declare const find: (ast: ESQLAstQueryExpression, index: string, cluster?: string) => ESQLSource | undefined;
+export declare const remove: (ast: ESQLAstQueryExpression, index: string, cluster?: string) => ESQLSource | undefined;
+export declare const insert: (ast: ESQLAstQueryExpression, indexName: string, clusterName?: string, index?: number) => ESQLSource | undefined;
+export declare const upsert: (ast: ESQLAstQueryExpression, indexName: string, clusterName?: string, index?: number) => ESQLSource | undefined;
+//# sourceMappingURL=sources.d.ts.map

package/lib/ast/mutate/commands/from/sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/from/sources.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIzF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,GAAG,WAAW,CAAC,MAAM,CAAC,KAChD,gBAAgB,CAAC,UAAU,CAuB7B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,KAAK,sBAAsB,EAC3B,WAAW,SAAS,CAAC,UAAU,CAAC,KAC/B,UAAU,GAAG,SAEf,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,OAAO,MAAM,EACb,UAAU,MAAM,KACf,UAAU,GAAG,SAWf,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,OAAO,MAAM,EACb,UAAU,MAAM,KACf,UAAU,GAAG,SAUf,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,QAAO,MAAW,KACjB,UAAU,GAAG,SAgBf,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,QAAO,MAAW,KACjB,UAAU,GAAG,SAQf,CAAC"}

package/lib/ast/mutate/commands/index.d.ts

@@ -0,0 +1,9 @@
+import * as from from './from';
+import * as limit from './limit';
+import * as sort from './sort';
+import * as stats from './stats';
+import * as where from './where';
+import * as join from './join';
+import * as rerank from './rerank';
+export { from, limit, sort, stats, where, join, rerank };
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ast/mutate/commands/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC"}

package/lib/ast/mutate/commands/join/index.d.ts

@@ -0,0 +1,17 @@
+import type { ESQLAstJoinCommand, ESQLAstQueryExpression, ESQLCommand } from '../../../../types';
+/**
+ * Lists all "JOIN" commands in the query AST.
+ *
+ * @param ast The root AST node to search for "JOIN" commands.
+ * @returns A collection of "JOIN" commands.
+ */
+export declare const list: (ast: ESQLAstQueryExpression) => IterableIterator<ESQLAstJoinCommand>;
+/**
+ * Retrieves the "JOIN" command at the specified index in order of appearance.
+ *
+ * @param ast The root AST node to search for "JOIN" commands.
+ * @param index The index of the "JOIN" command to retrieve.
+ * @returns The "JOIN" command at the specified index, if any.
+ */
+export declare const byIndex: (ast: ESQLAstQueryExpression, index: number) => ESQLCommand | undefined;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/join/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/join/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGjG;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,sBAAsB,KAAG,gBAAgB,CAAC,kBAAkB,CAKrF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,sBAAsB,EAAE,OAAO,MAAM,KAAG,WAAW,GAAG,SAElF,CAAC"}

package/lib/ast/mutate/commands/limit/index.d.ts

@@ -0,0 +1,56 @@
+import type { ESQLAstQueryExpression, ESQLCommand } from '../../../../types';
+import type { Predicate } from '../../types';
+/**
+ * Lists all "LIMIT" commands in the query AST.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @returns A collection of "LIMIT" commands.
+ */
+export declare const list: (ast: ESQLAstQueryExpression) => IterableIterator<ESQLCommand>;
+/**
+ * Retrieves the "LIMIT" command at the specified index in order of appearance.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @param index The index of the "LIMIT" command to retrieve.
+ * @returns The "LIMIT" command at the specified index, if any.
+ */
+export declare const byIndex: (ast: ESQLAstQueryExpression, index: number) => ESQLCommand | undefined;
+/**
+ * Finds the first "LIMIT" command that satisfies the provided predicate.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @param predicate The predicate function to apply to each "LIMIT" command.
+ * @returns The first "LIMIT" command that satisfies the predicate, if any.
+ */
+export declare const find: (ast: ESQLAstQueryExpression, predicate: Predicate<ESQLCommand>) => ESQLCommand | undefined;
+/**
+ * Deletes the specified "LIMIT" command from the query AST.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @param index The index of the "LIMIT" command to remove.
+ * @returns The removed "LIMIT" command, if any.
+ */
+export declare const remove: (ast: ESQLAstQueryExpression, index?: number) => ESQLCommand | undefined;
+/**
+ * Sets the value of the specified "LIMIT" command. If `indexOrPredicate` is not
+ * specified will update the first "LIMIT" command found, if any.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @param value The new value to set.
+ * @param indexOrPredicate The index of the "LIMIT" command to update, or a
+ *     predicate function.
+ * @returns The updated "LIMIT" command, if any.
+ */
+export declare const set: (ast: ESQLAstQueryExpression, value: number, indexOrPredicate?: number | Predicate<ESQLCommand>) => ESQLCommand | undefined;
+/**
+ * Updates the value of the specified "LIMIT" command. If the "LIMIT" command
+ * is not found, a new one will be created and appended to the query AST.
+ *
+ * @param ast The root AST node to search for "LIMIT" commands.
+ * @param value The new value to set.
+ * @param indexOrPredicate The index of the "LIMIT" command to update, or a
+ *     predicate function.
+ * @returns The updated or newly created "LIMIT" command.
+ */
+export declare const upsert: (ast: ESQLAstQueryExpression, value: number, indexOrPredicate?: number | Predicate<ESQLCommand>) => ESQLCommand;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/limit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/limit/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,sBAAsB,KAAG,gBAAgB,CAAC,WAAW,CAE9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,sBAAsB,EAAE,OAAO,MAAM,KAAG,WAAW,GAAG,SAElF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,WAAW,SAAS,CAAC,WAAW,CAAC,KAChC,WAAW,GAAG,SAEhB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,sBAAsB,EAAE,QAAO,MAAU,KAAG,WAAW,GAAG,SAcrF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,GACd,KAAK,sBAAsB,EAC3B,OAAO,MAAM,EACb,mBAAkB,MAAM,GAAG,SAAS,CAAC,WAAW,CAAK,KACpD,WAAW,GAAG,SAehB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,OAAO,MAAM,EACb,mBAAkB,MAAM,GAAG,SAAS,CAAC,WAAW,CAAK,KACpD,WAgBF,CAAC"}

package/lib/ast/mutate/commands/rerank/index.d.ts

@@ -0,0 +1,41 @@
+import type { ESQLAstQueryExpression, ESQLAstRerankCommand, ESQLStringLiteral, ESQLParamLiteral } from '../../../../types';
+/**
+ * Lists all "RERANK" commands in the query AST.
+ *
+ * @param ast The root AST node to search for "RERANK" commands.
+ * @returns A collection of "RERANK" commands.
+ */
+export declare const list: (ast: ESQLAstQueryExpression) => IterableIterator<ESQLAstRerankCommand>;
+/**
+ * Sets or updates the query text for the RERANK command.
+ *
+ * @param cmd The RERANK command AST node to modify.
+ * @param query The query text to set.
+ */
+export declare const setQuery: (cmd: ESQLAstRerankCommand, query: string | ESQLStringLiteral) => void;
+/**
+ * Sets, updates, or removes the target field for the RERANK command.
+ * This refers to the `targetField =` portion of the command, which specifies                                  │
+ * the new column where the rerank score will be stored.                                                       │
+ *
+ * @param cmd The RERANK command AST node to modify.
+ * @param target The name of the target field to set. If `null` the assignment is removed.
+ */
+export declare const setTargetField: (cmd: ESQLAstRerankCommand, target: string | null) => void;
+/**
+ * Sets or updates the fields to be used for reranking in the ON clause.
+ *
+ * @param cmd The RERANK command AST node to modify.
+ * @param fields An array of field names or field nodes.
+ */
+export declare const setFields: (cmd: ESQLAstRerankCommand, fields: string[] | ESQLAstRerankCommand["fields"]) => void;
+/**
+ * Sets a parameter in the WITH clause of the RERANK command (e.g., 'inference_id').
+ * If the parameter already exists, its value is updated. Otherwise, it is added.
+ *
+ * @param cmd The RERANK command AST node to modify.
+ * @param key The name of the parameter to set.
+ * @param value The value of the parameter.
+ */
+export declare const setWithParameter: (cmd: ESQLAstRerankCommand, key: string, value: string | ESQLStringLiteral | ESQLParamLiteral) => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/rerank/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/rerank/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,sBAAsB,EACtB,oBAAoB,EAEpB,iBAAiB,EACjB,gBAAgB,EAKjB,MAAM,mBAAmB,CAAC;AAG3B;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,sBAAsB,KAAG,gBAAgB,CAAC,oBAAoB,CAKvF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,oBAAoB,EAAE,OAAO,MAAM,GAAG,iBAAiB,SAkBpF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,oBAAoB,EAAE,QAAQ,MAAM,GAAG,IAAI,SA+B9E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,KAAK,oBAAoB,EACzB,QAAQ,MAAM,EAAE,GAAG,oBAAoB,CAAC,QAAQ,CAAC,SAwBlD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,oBAAoB,EACzB,KAAK,MAAM,EACX,OAAO,MAAM,GAAG,iBAAiB,GAAG,gBAAgB,SAqErD,CAAC"}

package/lib/ast/mutate/commands/sort/index.d.ts

@@ -0,0 +1,117 @@
+import type { ESQLAstQueryExpression, ESQLColumn, ESQLCommand, ESQLOrderExpression } from '../../../../types';
+import type { Predicate } from '../../types';
+export type SortExpression = ESQLOrderExpression | ESQLColumn;
+/**
+ * This "template" allows the developer to easily specify a new sort expression
+ * AST node, for example:
+ *
+ * ```ts
+ * // as a simple string
+ * 'column_name'
+ *
+ * // column with nested fields
+ * ['column_name', 'nested_field']
+ *
+ * // as an object with additional options
+ * { parts: 'column_name', order: 'ASC', nulls: 'NULLS FIRST' }
+ * { parts: ['column_name', 'nested_field'], order: 'DESC', nulls: 'NULLS LAST' }
+ * ```
+ */
+export type NewSortExpressionTemplate = string | string[] | {
+    parts: string | string[];
+    order?: ESQLOrderExpression['order'];
+    nulls?: ESQLOrderExpression['nulls'];
+};
+/**
+ * Iterates through all sort commands starting from the beginning of the query.
+ * You can specify the `skip` parameter to skip a given number of sort commands.
+ *
+ * @param ast The root of the AST.
+ * @param skip Number of sort commands to skip.
+ * @returns Iterator through all sort commands.
+ */
+export declare const listCommands: (ast: ESQLAstQueryExpression, skip?: number) => IterableIterator<ESQLCommand>;
+/**
+ * Returns the Nth SORT command found in the query.
+ *
+ * @param ast The root of the AST.
+ * @param index The index (N) of the sort command to return.
+ * @returns The sort command found in the AST, if any.
+ */
+export declare const getCommand: (ast: ESQLAstQueryExpression, index?: number) => ESQLCommand | undefined;
+/**
+ * Returns an iterator for all sort expressions (columns and order expressions)
+ * in the query. You can specify the `skip` parameter to skip a given number of
+ * expressions.
+ *
+ * @param ast The root of the AST.
+ * @param skip Number of sort expressions to skip.
+ * @returns Iterator through sort expressions (columns and order expressions).
+ */
+export declare const list: (ast: ESQLAstQueryExpression, skip?: number) => IterableIterator<[sortExpression: SortExpression, sortCommand: ESQLCommand]>;
+/**
+ * Finds the Nts sort expression that matches the predicate.
+ *
+ * @param ast The root of the AST.
+ * @param predicate A function that returns true if the sort expression matches
+ *     the predicate.
+ * @param index The index of the sort expression to return. If not specified,
+ *     the first sort expression that matches the predicate will be returned.
+ * @returns The sort expressions and sort command 2-tuple that matches the
+ *     predicate, if any.
+ */
+export declare const findByPredicate: (ast: ESQLAstQueryExpression, predicate: Predicate<[sortExpression: SortExpression, sortCommand: ESQLCommand]>, index?: number) => [sortExpression: SortExpression, sortCommand: ESQLCommand] | undefined;
+/**
+ * Finds the Nth sort expression that matches the sort expression by column
+ * name. The `parts` argument allows to specify an array of nested field names.
+ *
+ * @param ast The root of the AST.
+ * @param parts A string or an array of strings representing the column name.
+ * @returns The sort expressions and sort command 2-tuple that matches the
+ *     predicate, if any.
+ */
+export declare const find: (ast: ESQLAstQueryExpression, parts: string | string[], index?: number) => [sortExpression: SortExpression, sortCommand: ESQLCommand] | undefined;
+/**
+ * Removes the Nth sort expression that matches the sort expression by column
+ * name. The `parts` argument allows to specify an array of nested field names.
+ *
+ * @param ast The root of the AST.
+ * @param parts A string or an array of strings representing the column name.
+ * @param index The index of the sort expression to remove.
+ * @returns The sort expressions and sort command 2-tuple that was removed, if any.
+ */
+export declare const remove: (ast: ESQLAstQueryExpression, parts: string | string[], index?: number) => [sortExpression: SortExpression, sortCommand: ESQLCommand] | undefined;
+/**
+ * Inserts a new sort expression into the specified SORT command at the
+ * specified argument position.
+ *
+ * @param sortCommand The SORT command to insert the new sort expression into.
+ * @param template The sort expression template.
+ * @param index Argument position in the command argument list.
+ * @returns The inserted sort expression.
+ */
+export declare const insertIntoCommand: (sortCommand: ESQLCommand, template: NewSortExpressionTemplate, index?: number) => SortExpression;
+/**
+ * Creates a new sort expression node and inserts it into the specified SORT
+ * command at the specified argument position. If not sort command is found, a
+ * new one is created and appended to the end of the query.
+ *
+ * @param ast The root AST node.
+ * @param parts ES|QL column name parts.
+ * @param index The new column name position in command argument list.
+ * @param sortCommandIndex The index of the SORT command in the AST. E.g. 0 is the
+ *     first SORT command in the AST.
+ * @returns The inserted column AST node.
+ */
+export declare const insertExpression: (ast: ESQLAstQueryExpression, template: NewSortExpressionTemplate, index?: number, sortCommandIndex?: number) => SortExpression;
+/**
+ * Inserts a new SORT command with a single sort expression as its sole argument.
+ * You can specify the position to insert the command at.
+ *
+ * @param ast The root of the AST.
+ * @param template The sort expression template.
+ * @param index The position to insert the sort expression at.
+ * @returns The inserted sort expression and the command it was inserted into.
+ */
+export declare const insertCommand: (ast: ESQLAstQueryExpression, template: NewSortExpressionTemplate, index?: number) => [ESQLCommand, SortExpression];
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/sort/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/sort/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EACV,WAAW,EACX,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,yBAAyB,GACjC,MAAM,GACN,MAAM,EAAE,GACR;IACE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;CACtC,CAAC;AA8BN;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,sBAAsB,EAC3B,OAAM,MAAU,KACf,gBAAgB,CAAC,WAAW,CAgB9B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,KAAK,sBAAsB,EAC3B,QAAO,MAAU,KAChB,WAAW,GAAG,SAIhB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,OAAM,MAAU,KACf,gBAAgB,CAAC,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,CAoB7E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,sBAAsB,EAC3B,WAAW,SAAS,CAAC,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,EAChF,QAAQ,MAAM,KACb,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,GAAG,SAE/D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,OAAO,MAAM,GAAG,MAAM,EAAE,EACxB,QAAO,MAAU,KAChB,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,GAAG,SA8B/D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,OAAO,MAAM,GAAG,MAAM,EAAE,EACxB,QAAQ,MAAM,KACb,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,CAAC,GAAG,SAiB/D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC5B,aAAa,WAAW,EACxB,UAAU,yBAAyB,EACnC,QAAQ,MAAM,KACb,cAMF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,sBAAsB,EAC3B,UAAU,yBAAyB,EACnC,QAAO,MAAW,EAClB,mBAAkB,MAAU,KAC3B,cASF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,sBAAsB,EAC3B,UAAU,yBAAyB,EACnC,QAAO,MAAW,KACjB,CAAC,WAAW,EAAE,cAAc,CAO9B,CAAC"}

package/lib/ast/mutate/commands/stats/index.d.ts

@@ -0,0 +1,17 @@
+import type { ESQLAstQueryExpression, ESQLCommand } from '../../../../types';
+/**
+ * Lists all "STATS" commands in the query AST.
+ *
+ * @param ast The root AST node to search for "STATS" commands.
+ * @returns A collection of "STATS" commands.
+ */
+export declare const list: (ast: ESQLAstQueryExpression) => IterableIterator<ESQLCommand>;
+/**
+ * Retrieves the "STATS" command at the specified index in order of appearance.
+ *
+ * @param ast The root AST node to search for "STATS" commands.
+ * @param index The index of the "STATS" command to retrieve.
+ * @returns The "STATS" command at the specified index, if any.
+ */
+export declare const byIndex: (ast: ESQLAstQueryExpression, index: number) => ESQLCommand | undefined;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/stats/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/stats/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG7E;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,sBAAsB,KAAG,gBAAgB,CAAC,WAAW,CAE9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,sBAAsB,EAAE,OAAO,MAAM,KAAG,WAAW,GAAG,SAElF,CAAC"}

package/lib/ast/mutate/commands/where/index.d.ts

@@ -0,0 +1,48 @@
+import type { ESQLAstQueryExpression, ESQLColumn, ESQLCommand, ESQLIdentifier, ESQLParamLiteral, ESQLProperNode } from '../../../../types';
+/**
+ * Lists all "WHERE" commands in the query AST.
+ *
+ * @param ast The root AST node to search for "WHERE" commands.
+ * @returns A collection of "WHERE" commands.
+ */
+export declare const list: (ast: ESQLAstQueryExpression) => IterableIterator<ESQLCommand>;
+/**
+ * Retrieves the "WHERE" command at the specified index in order of appearance.
+ *
+ * @param ast The root AST node to search for "WHERE" commands.
+ * @param index The index of the "WHERE" command to retrieve.
+ * @returns The "WHERE" command at the specified index, if any.
+ */
+export declare const byIndex: (ast: ESQLAstQueryExpression, index: number) => ESQLCommand | undefined;
+export type ESQLAstField = ESQLColumn | ESQLIdentifier | ESQLParamLiteral;
+export type ESQLAstFieldTemplate = string | string[] | ESQLAstField;
+/**
+ * Finds the first "WHERE" command which contains the specified text as one of
+ * its comparison operands. The text can represent a field (including nested
+ * fields or a single identifier), or a param. If the text starts with "?", it
+ * is assumed to be a param.
+ *
+ * Examples:
+ *
+ * ```ts
+ * byField(ast, 'field');
+ * byField(ast, ['nested', 'field']);
+ * byField(ast, '?param');
+ * byField(ast, ['nested', '?param']);
+ * byField(ast, ['nested', 'positional', 'param', '?123']);
+ * byField(ast, '?');
+ * ```
+ *
+ * Alternatively you can build your own field template using the builder:
+ *
+ * ```ts
+ * byField(ast, Builder.expression.column({
+ *   args: [Builder.identifier({ name: 'field' })]
+ * }));
+ * ```
+ *
+ * @param ast The root AST node search for "WHERE" commands.
+ * @param text The text or nested column name texts to search for.
+ */
+export declare const byField: (ast: ESQLAstQueryExpression, template: ESQLAstFieldTemplate) => [command: ESQLCommand, field: ESQLProperNode] | undefined;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/commands/where/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/commands/where/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EACV,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAG3B;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,sBAAsB,KAAG,gBAAgB,CAAC,WAAW,CAE9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,sBAAsB,EAAE,OAAO,MAAM,KAAG,WAAW,GAAG,SAElF,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAC1E,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,YAAY,CAAC;AA4BpE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,OAAO,GAClB,KAAK,sBAAsB,EAC3B,UAAU,oBAAoB,KAC7B,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,cAAc,CAAC,GAAG,SA2BlD,CAAC"}

package/lib/ast/mutate/generic/commands/args/index.d.ts

@@ -0,0 +1,14 @@
+import type { ESQLAstQueryExpression, ESQLCommand, ESQLProperNode, ESQLSingleAstItem } from '../../../../../types';
+export declare const insert: (command: ESQLCommand, expression: ESQLSingleAstItem, index?: number) => number;
+export declare const append: (command: ESQLCommand, expression: ESQLSingleAstItem) => number;
+/**
+ * Searches all command arguments in the query AST node and removes the node
+ * from the command's arguments list. This function recursively searches through
+ * subqueries as well.
+ *
+ * @param ast The root AST node to search for command arguments.
+ * @param node The argument AST node to remove.
+ * @returns Returns the command that the argument was removed from, if any.
+ */
+export declare const remove: (ast: ESQLAstQueryExpression, node: ESQLProperNode) => ESQLCommand | undefined;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/generic/commands/args/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/ast/mutate/generic/commands/args/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAG9B,eAAO,MAAM,MAAM,GACjB,SAAS,WAAW,EACpB,YAAY,iBAAiB,EAC7B,QAAO,MAAW,KACjB,MAqBF,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,SAAS,WAAW,EAAE,YAAY,iBAAiB,KAAG,MAE5E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,MAAM,cAAc,KACnB,WAAW,GAAG,SAmChB,CAAC"}

package/lib/ast/mutate/generic/commands/index.d.ts

@@ -0,0 +1,54 @@
+import type { ESQLAstQueryExpression, ESQLCommand } from '../../../../types';
+import type { Predicate } from '../../types';
+export * as args from './args';
+export * as options from './options';
+/**
+ * Returns an iterator for all command AST nodes in the query. If a predicate is
+ * provided, only commands that satisfy the predicate will be returned.
+ *
+ * @param ast Root AST node to search for commands.
+ * @param predicate Optional predicate to filter commands.
+ * @returns A list of commands found in the AST.
+ */
+export declare const list: (ast: ESQLAstQueryExpression, predicate?: Predicate<ESQLCommand>) => IterableIterator<ESQLCommand>;
+/**
+ * Returns the first command AST node at a given index in the query that
+ * satisfies the predicate. If no index is provided, the first command found
+ * will be returned.
+ *
+ * @param ast Root AST node to search for commands.
+ * @param predicate Optional predicate to filter commands.
+ * @param index The index of the command to return.
+ * @returns The command found in the AST, if any.
+ */
+export declare const find: (ast: ESQLAstQueryExpression, predicate?: Predicate<ESQLCommand>, index?: number) => ESQLCommand | undefined;
+/**
+ * Returns the first command AST node at a given index with a given name in the
+ * query. If no index is provided, the first command found will be returned.
+ *
+ * @param ast Root AST node to search for commands.
+ * @param commandName The name of the command to find.
+ * @param index The index of the command to return.
+ * @returns The command found in the AST, if any.
+ */
+export declare const findByName: (ast: ESQLAstQueryExpression, commandName: string, index?: number) => ESQLCommand | undefined;
+/**
+ * Inserts a new command into the query AST node at the specified index. If the
+ * `index` is out of bounds, the command will be appended to the end of the
+ * command list.
+ *
+ * @param ast The root AST node.
+ * @param command The command AST node to insert.
+ * @param index The index to insert the command at.
+ * @returns The index the command was inserted at.
+ */
+export declare const insert: (ast: ESQLAstQueryExpression, command: ESQLCommand, index?: number) => number;
+/**
+ * Adds a new command to the query AST node.
+ *
+ * @param ast The root AST node to append the command to.
+ * @param command The command AST node to append.
+ */
+export declare const append: (ast: ESQLAstQueryExpression, command: ESQLCommand) => void;
+export declare const remove: (ast: ESQLAstQueryExpression, command: ESQLCommand) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/generic/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ast/mutate/generic/commands/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,YAAY,SAAS,CAAC,WAAW,CAAC,KACjC,gBAAgB,CAAC,WAAW,CAU9B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,sBAAsB,EAC3B,YAAY,SAAS,CAAC,WAAW,CAAC,EAClC,QAAO,MAAU,KAChB,WAAW,GAAG,SAUhB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GACrB,KAAK,sBAAsB,EAC3B,aAAa,MAAM,EACnB,QAAO,MAAU,KAChB,WAAW,GAAG,SAEhB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,sBAAsB,EAC3B,SAAS,WAAW,EACpB,QAAO,MAAiB,KACvB,MAUF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,sBAAsB,EAAE,SAAS,WAAW,KAAG,IAE1E,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,KAAK,sBAAsB,EAAE,SAAS,WAAW,KAAG,OAY1E,CAAC"}

package/lib/ast/mutate/generic/commands/options/index.d.ts

@@ -0,0 +1,38 @@
+import type { ESQLAstQueryExpression, ESQLCommand, ESQLCommandOption } from '../../../../../types';
+import type { Predicate } from '../../../types';
+/**
+ * Returns the first command option AST node that satisfies the predicate.
+ *
+ * @param command The command AST node to search for options.
+ * @param predicate The predicate to filter options.
+ * @returns The option found in the command, if any.
+ */
+export declare const find: (command: ESQLCommand, predicate: Predicate<ESQLCommandOption>) => ESQLCommandOption | undefined;
+/**
+ * Returns the first command option AST node with a given name in the query.
+ *
+ * @param ast The root AST node to search for command options.
+ * @param commandName Command name to search for.
+ * @param optionName Option name to search for.
+ * @returns The option found in the command, if any.
+ */
+export declare const findByName: (ast: ESQLAstQueryExpression, commandName: string, optionName: string) => ESQLCommandOption | undefined;
+/**
+ * Inserts a command option into the command's arguments list. The option can
+ * be specified as a string or an AST node.
+ *
+ * @param command The command AST node to insert the option into.
+ * @param option The option to insert.
+ * @returns The inserted option.
+ */
+export declare const append: (command: ESQLCommand, option: string | ESQLCommandOption) => ESQLCommandOption;
+/**
+ * Removes the first command option from the command's arguments list that
+ * satisfies the predicate.
+ *
+ * @param command The command AST node to remove the option from.
+ * @param predicate The predicate to filter options.
+ * @returns The removed option, if any.
+ */
+export declare const remove: (ast: ESQLAstQueryExpression, option: ESQLCommandOption) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/generic/commands/options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/ast/mutate/generic/commands/options/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,sBAAsB,EACtB,WAAW,EACX,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,WAAW,EACpB,WAAW,SAAS,CAAC,iBAAiB,CAAC,KACtC,iBAAiB,GAAG,SAYtB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GACrB,KAAK,sBAAsB,EAC3B,aAAa,MAAM,EACnB,YAAY,MAAM,KACjB,iBAAiB,GAAG,SAQtB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GACjB,SAAS,WAAW,EACpB,QAAQ,MAAM,GAAG,iBAAiB,KACjC,iBAQF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,sBAAsB,EAAE,QAAQ,iBAAiB,KAAG,OAuC/E,CAAC"}

package/lib/ast/mutate/generic/index.d.ts

@@ -0,0 +1,2 @@
+export * as commands from './commands';
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/generic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ast/mutate/generic/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}

package/lib/ast/mutate/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './types';
+import * as generic from './generic';
+import * as commands from './commands';
+export { generic, commands };
+//# sourceMappingURL=index.d.ts.map

package/lib/ast/mutate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/mutate/index.ts"],"names":[],"mappings":"AAOA,mBAAmB,SAAS,CAAC;AAE7B,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/lib/ast/mutate/types.d.ts

@@ -0,0 +1,2 @@
+export type Predicate<T> = (item: T) => boolean;
+//# sourceMappingURL=types.d.ts.map

package/lib/ast/mutate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ast/mutate/types.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC"}

package/lib/ast/mutate/util.d.ts

@@ -0,0 +1,20 @@
+import type { Predicate } from './types';
+/**
+ * Find the first item in an iterable (such as array) that matches a predicate.
+ *
+ * @param iterable List of items to search through.
+ * @param predicate Function to determine if an item is the one we are looking
+ *     for.
+ * @returns The first item that matches the predicate, or undefined if no item
+ *     matches.
+ */
+export declare const findByPredicate: <T>(iterable: IterableIterator<T>, predicate: Predicate<T>) => T | undefined;
+/**
+ * Shallowly compares two arrays for equality.
+ *
+ * @param a The first array to compare.
+ * @param b The second array to compare.
+ * @returns True if the arrays are equal, false otherwise.
+ */
+export declare const cmpArr: <T>(a: T[], b: T[]) => boolean;
+//# sourceMappingURL=util.d.ts.map

package/lib/ast/mutate/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/ast/mutate/util.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAC/B,UAAU,gBAAgB,CAAC,CAAC,CAAC,EAC7B,WAAW,SAAS,CAAC,CAAC,CAAC,KACtB,CAAC,GAAG,SAON,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAG,OAY1C,CAAC"}