@platforma-open/milaboratories.software-ptabler.schema 1.11.2 → 1.11.4

package/dist/aggregate.d.ts

@@ -1,4 +1,4 @@
-import { Expression, AggregationType } from './expressions';
+import type { Expression, AggregationType } from './expressions';
 /**
  * Defines aggregation functions that select a value from one expression based on the min/max of another expression.
  */
@@ -53,3 +53,4 @@ export interface AggregateStep {
     /** An array of aggregation operations to apply to the input table. */
     aggregations: (StandardAggregationOperation | ByClauseAggregationOperation)[];
 }
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../src/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,WAAW,EAAE,eAAe,CAAC;IAC7B;;;;;OAKG;IACH,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,WAAW,EAAE,uBAAuB,CAAC;IACrC,8CAA8C;IAC9C,UAAU,EAAE,UAAU,CAAC;IACvB;;;OAGG;IACH,EAAE,EAAE,UAAU,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,IAAI,EAAE,WAAW,CAAC;IAClB,uFAAuF;IACvF,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,WAAW,EAAE,MAAM,CAAC;IACpB,kGAAkG;IAClG,OAAO,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,CAAC;IACjC,sEAAsE;IACtE,YAAY,EAAE,CAAC,4BAA4B,GAAG,4BAA4B,CAAC,EAAE,CAAC;CAC/E"}

package/dist/basic_steps.d.ts

@@ -1,4 +1,4 @@
-import { Expression } from './expressions';
+import type { Expression } from './expressions';
 /**
  * Defines a step that adds one or more new columns to an existing table in the tablespace.
  * This operation modifies the specified table in place.
@@ -17,17 +17,7 @@ export interface AddColumnsStep {
      * An array defining the new columns to be added.
      * Each object in the array specifies the name of a new column and the expression to compute its values.
      */
-    columns: {
-        /**
-         * The name of the new column.
-         */
-        name: string;
-        /**
-         * An Expression object defining how to compute the column's values.
-         * The expression will be evaluated for each row to generate the values for the new column.
-         */
-        expression: Expression;
-    }[];
+    columns: Expression[];
 }
 /**
  * Defines a step that filters rows in a table based on a specified condition
@@ -81,18 +71,7 @@ export interface SelectStep {
      * Each object in the array specifies the name of a column in the output table
      * and the expression to compute its values.
      */
-    columns: {
-        /**
-         * The name of the column in the output table.
-         */
-        name: string;
-        /**
-         * An Expression object defining how to compute the column's values.
-         * This expression will be evaluated to generate the values for this column
-         * in the output table.
-         */
-        expression: Expression;
-    }[];
+    columns: Expression[];
 }
 /**
  * Defines a step that adds new columns to an input table (or replaces existing ones
@@ -121,17 +100,7 @@ export interface WithColumnsStep {
      * Each object in the array specifies the name of a column and the
      * expression to compute its values.
      */
-    columns: {
-        /**
-         * The name of the new or replacement column.
-         */
-        name: string;
-        /**
-         * An Expression object defining how to compute the column's values.
-         * The expression will be evaluated for each row to generate the values for the column.
-         */
-        expression: Expression;
-    }[];
+    columns: Expression[];
 }
 /**
  * Defines a step that excludes a specific set of columns from an input table
@@ -158,3 +127,29 @@ export interface WithoutColumnsStep {
      */
     columns: string[];
 }
+/**
+ * Defines a step that limits the number of rows in a table
+ * and outputs the result to a new table in the tablespace.
+ * This operation is similar to Polars' `limit` method.
+ */
+export interface LimitStep {
+    /**
+     * The type identifier for this step.
+     * Must be 'limit'.
+     */
+    type: 'limit';
+    /**
+     * The name of the input table in the tablespace from which rows will be limited.
+     */
+    inputTable: string;
+    /**
+     * The name for the resulting table that will be added to the tablespace.
+     * This new table will contain only the first n rows from the input table.
+     */
+    outputTable: string;
+    /**
+     * The maximum number of rows to include in the output table.
+     */
+    n: number;
+}
+//# sourceMappingURL=basic_steps.d.ts.map

package/dist/basic_steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic_steps.d.ts","sourceRoot":"","sources":["../src/basic_steps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC;IAEpB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,SAAS,EAAE,UAAU,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,IAAI,EAAE,cAAc,CAAC;IAErB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,IAAI,EAAE,iBAAiB,CAAC;IAExB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;IAEd;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,CAAC,EAAE,MAAM,CAAC;CACX"}

package/dist/common.d.ts

@@ -8,3 +8,4 @@
  * - 'Double': maps to 'Float64'
  */
 export type DataType = 'Int8' | 'Int16' | 'Int32' | 'Int64' | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64' | 'Float32' | 'Float64' | 'Boolean' | 'String' | 'Date' | 'Datetime' | 'Time' | 'Int' | 'Long' | 'Float' | 'Double';
+//# sourceMappingURL=common.d.ts.map

package/dist/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAChB,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,SAAS,GACT,QAAQ,GACR,MAAM,GACN,UAAU,GACV,MAAM,GAEN,KAAK,GACL,MAAM,GACN,OAAO,GACP,QAAQ,CAAC"}

package/dist/concatenate.d.ts

@@ -20,3 +20,4 @@ export interface ConcatenateStep {
      */
     columns?: string[];
 }
+//# sourceMappingURL=concatenate.d.ts.map

package/dist/concatenate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concatenate.d.ts","sourceRoot":"","sources":["../src/concatenate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,IAAI,EAAE,aAAa,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,yFAAyF;IACzF,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB"}

package/dist/expressions/base.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Forward declaration of the Expression type.
+ * The real type is defined in [index.ts](./index.ts) file to avoid circular dependencies.
+ */
+export { type Expression } from './index';
+//# sourceMappingURL=base.d.ts.map

package/dist/expressions/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/expressions/base.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/expressions/basics.d.ts

@@ -0,0 +1,131 @@
+import type { AxisSpec } from '@milaboratories/pl-model-common';
+import type { DataType } from '../common';
+import type { Expression } from './base';
+/** Represents all possible comparison operator types. */
+export type ComparisonOperator = 'gt' | 'ge' | 'eq' | 'lt' | 'le' | 'neq';
+/** Defines a comparison operation between two expressions. */
+export interface ComparisonExpression {
+    /** The type of comparison (e.g., 'gt', 'eq'). */
+    type: ComparisonOperator;
+    /** The left-hand side expression. */
+    lhs: Expression;
+    /** The right-hand side expression. */
+    rhs: Expression;
+}
+/** Defines the supported binary arithmetic operators. */
+export type BinaryArithmeticOperator = 'plus' | 'minus' | 'multiply' | 'truediv' | 'floordiv';
+/** Represents a binary arithmetic operation between two expressions. */
+export interface BinaryArithmeticExpression {
+    /** The type of arithmetic operation (e.g., 'plus', 'minus'). */
+    type: BinaryArithmeticOperator;
+    /** The left-hand side expression. */
+    lhs: Expression;
+    /** The right-hand side expression. */
+    rhs: Expression;
+}
+/** Defines the supported unary arithmetic operators. */
+export type UnaryArithmeticOperator = 'log10' | 'log' | 'log2' | 'abs' | 'sqrt' | 'negate' | 'floor' | 'round' | 'ceil';
+/** Represents a unary arithmetic operation on a single expression. */
+export interface UnaryArithmeticExpression {
+    /** The type of unary operation (e.g., 'log10', 'abs'). */
+    type: UnaryArithmeticOperator;
+    /** The expression to operate on. */
+    value: Expression;
+}
+/**
+ * Represents a type casting operation that converts the result of an expression to a specified data type.
+ */
+export interface CastExpression {
+    /** The type of operation, always 'cast'. */
+    type: 'cast';
+    /** The expression whose result will be cast to the target data type. */
+    value: Expression;
+    /** The target data type to cast the expression result to. */
+    dtype: DataType;
+    /**
+     * Whether to use strict casting mode. If true, conversion errors and overflows will throw exceptions.
+     * If false or undefined, uses non-strict mode where failures result in null values. Defaults to false.
+     */
+    strict?: boolean;
+}
+/** Defines the supported boolean list operators. */
+export type BooleanListOperator = 'and' | 'or';
+/** Represents a boolean logic operation (AND, OR) on a list of expressions. */
+export interface BooleanLogicExpression {
+    /** The type of boolean operation ('and', 'or'). */
+    type: BooleanListOperator;
+    /** An array of boolean expressions as operands. */
+    operands: Expression[];
+}
+/** Represents a logical NOT operation on a single boolean expression. */
+export interface NotExpression {
+    /** The type of operation, always 'not'. */
+    type: 'not';
+    /** The boolean expression to negate. */
+    value: Expression;
+}
+/** Defines the supported null check operators. */
+export type NullCheckOperator = 'is_na' | 'is_not_na';
+/** Represents a null check operation (is NA, is not NA) on an expression. */
+export interface NullCheckExpression {
+    /** The type of null check ('is_na', 'is_not_na'). */
+    type: NullCheckOperator;
+    /** The expression to check for nullity. */
+    value: Expression;
+}
+/** Represents a reference to a column by its name. */
+export interface ColumnReferenceExpression {
+    /** The type of operation, always 'col'. */
+    type: 'col';
+    /** The name of the column to reference. */
+    name: string;
+}
+/** Represents a reference to an axis by its specification (or id). */
+export interface AxisReferenceExpression {
+    /** The type of operation, always 'axis'. */
+    type: 'axis';
+    /** The axis to reference. */
+    spec: AxisSpec;
+}
+/** Represents a constant literal value (string, number, boolean, or null). */
+export interface ConstantValueExpression {
+    /** The type of operation, always 'const'. */
+    type: 'const';
+    /** The constant value. */
+    value: string | number | boolean | null;
+}
+/** Defines the supported min/max operators. */
+export type MinMaxOperator = 'min' | 'max';
+/** Represents a min or max operation on a list of expressions. */
+export interface MinMaxExpression {
+    /** The type of operation ('min' or 'max'). */
+    type: MinMaxOperator;
+    /** An array of expressions to find the minimum or maximum value from. */
+    operands: Expression[];
+}
+/**
+ * Represents an "in set" operation.
+ * Checks if the value of an expression is contained within a specified set of values.
+ * Returns true if the expression's value is found in the set, false otherwise.
+ */
+export interface InSetExpression {
+    /** The type of operation, always 'in_set'. */
+    type: 'in_set';
+    /** The expression whose value will be checked for membership in the set. */
+    value: Expression;
+    /** The set of values to check membership against. */
+    set: (string | number | boolean | null)[];
+}
+/**
+ * Represents an alias operation.
+ * This operation creates a new expression with a specified alias.
+ */
+export interface AliasExpression {
+    /** The type of operation, always 'alias'. */
+    type: 'alias';
+    /** The expression to alias. */
+    value: Expression;
+    /** The alias name. */
+    name: string;
+}
+//# sourceMappingURL=basics.d.ts.map

package/dist/expressions/basics.d.ts.map

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

package/dist/expressions/conditional.d.ts

@@ -0,0 +1,56 @@
+import type { Expression } from './base';
+/**
+ * Represents a single "when" condition and its corresponding "then" result expression.
+ * Used within the WhenThenOtherwiseExpression.
+ */
+export interface WhenThenClause {
+    /** The condition expression. Should evaluate to a boolean. */
+    when: Expression;
+    /** The result expression if the 'when' condition is true. */
+    then: Expression;
+}
+/**
+ * Represents a conditional expression that evaluates a series of "when"
+ * conditions and returns the corresponding "then" expression's value.
+ * If no "when" condition is met, it returns the value of the "otherwise" expression.
+ * This mimics Polars' when/then/otherwise functionality.
+ */
+export interface WhenThenOtherwiseExpression {
+    /** The type of operation, always 'when_then_otherwise'. */
+    type: 'when_then_otherwise';
+    /** An array of "when/then" clauses to be evaluated in order. */
+    conditions: WhenThenClause[];
+    /** The expression whose value is returned if none of the "when" conditions are met. */
+    otherwise: Expression;
+}
+/**
+ * Represents a fill null operation.
+ * If the 'input' expression evaluates to null, the 'fillValue' expression is used.
+ * Otherwise, the 'input' expression's value is used.
+ * This is a convenience shortcut for a common pattern often implemented with
+ * conditional expressions (e.g., when(is_null(input), fillValue).otherwise(input)).
+ */
+export interface FillNullExpression {
+    /** The type of operation, always 'fill_null'. */
+    type: 'fill_null';
+    /** The primary expression to evaluate. */
+    input: Expression;
+    /** The expression whose value is used if 'input' is null. */
+    fillValue: Expression;
+}
+/**
+ * Represents a fill NaN operation.
+ * If the 'input' expression evaluates to NaN, the 'fillValue' expression is used.
+ * Otherwise, the 'input' expression's value is used.
+ * This is a convenience shortcut for a common pattern often implemented with
+ * conditional expressions (e.g., when(is_nan(input), fillValue).otherwise(input)).
+ */
+export interface FillNaNExpression {
+    /** The type of operation, always 'fill_nan'. */
+    type: 'fill_nan';
+    /** The primary expression to evaluate. */
+    input: Expression;
+    /** The expression whose value is used if 'input' is NaN. */
+    fillValue: Expression;
+}
+//# sourceMappingURL=conditional.d.ts.map

package/dist/expressions/conditional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../src/expressions/conditional.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,8DAA8D;IAC9D,IAAI,EAAE,UAAU,CAAC;IACjB,6DAA6D;IAC7D,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C,2DAA2D;IAC3D,IAAI,EAAE,qBAAqB,CAAC;IAC5B,gEAAgE;IAChE,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,uFAAuF;IACvF,SAAS,EAAE,UAAU,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,IAAI,EAAE,WAAW,CAAC;IAClB,0CAA0C;IAC1C,KAAK,EAAE,UAAU,CAAC;IAClB,6DAA6D;IAC7D,SAAS,EAAE,UAAU,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,IAAI,EAAE,UAAU,CAAC;IACjB,0CAA0C;IAC1C,KAAK,EAAE,UAAU,CAAC;IAClB,4DAA4D;IAC5D,SAAS,EAAE,UAAU,CAAC;CACvB"}

package/dist/expressions/fuzzy.d.ts

@@ -0,0 +1,45 @@
+import type { Expression } from './base';
+/** Defines the supported string distance metrics. */
+export type StringDistanceMetric = 'levenshtein' | 'optimal_string_alignment' | 'jaro_winkler';
+/**
+ * Represents a string distance/similarity calculation between two expressions.
+ * Computes metrics like Levenshtein, Optimal String Alignment, or Jaro-Winkler.
+ */
+export interface StringDistanceExpression {
+    /** The type of operation, always 'string_distance'. */
+    type: 'string_distance';
+    /** The specific distance metric to use. */
+    metric: StringDistanceMetric;
+    /** The first string expression. */
+    string1: Expression;
+    /** The second string expression to compare against. */
+    string2: Expression;
+    /**
+     * If true, the expression returns a similarity score (typically normalized between 0 and 1).
+     * If false or undefined, it returns the raw edit distance (e.g., Levenshtein, OSA).
+     * Jaro-Winkler inherently returns a similarity score; this flag might be ignored or influence its normalization if applicable.
+     */
+    returnSimilarity?: boolean;
+}
+/** Defines the supported fuzzy string filter distance metrics. */
+export type FuzzyFilterDistanceMetric = 'levenshtein' | 'hamming';
+/**
+ * Represents a fuzzy string filter operation on an expression.
+ * This operation compares the string value of an expression (`value`)
+ * against another string or string expression (`pattern`) using a specified
+ * distance metric (`levenshtein` or `hamming`), returning true if the distance is
+ * within the specified `bound`.
+ */
+export interface FuzzyStringFilterExpression {
+    /** The type of operation, always 'fuzzy_string_filter'. */
+    type: 'fuzzy_string_filter';
+    /** The distance metric to use for the fuzzy comparison. */
+    metric: FuzzyFilterDistanceMetric;
+    /** The expression whose string value will be compared. */
+    value: Expression;
+    /** The expression representing the string pattern to compare against. */
+    pattern: Expression;
+    /** The maximum allowed distance for a match (inclusive). */
+    bound: number;
+}
+//# sourceMappingURL=fuzzy.d.ts.map

package/dist/expressions/fuzzy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy.d.ts","sourceRoot":"","sources":["../../src/expressions/fuzzy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,qDAAqD;AACrD,MAAM,MAAM,oBAAoB,GAC5B,aAAa,GACb,0BAA0B,GAC1B,cAAc,CAAC;AAEnB;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,uDAAuD;IACvD,IAAI,EAAE,iBAAiB,CAAC;IACxB,2CAA2C;IAC3C,MAAM,EAAE,oBAAoB,CAAC;IAC7B,mCAAmC;IACnC,OAAO,EAAE,UAAU,CAAC;IACpB,uDAAuD;IACvD,OAAO,EAAE,UAAU,CAAC;IACpB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,kEAAkE;AAClE,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG,SAAS,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IAC1C,2DAA2D;IAC3D,IAAI,EAAE,qBAAqB,CAAC;IAC5B,2DAA2D;IAC3D,MAAM,EAAE,yBAAyB,CAAC;IAClC,0DAA0D;IAC1D,KAAK,EAAE,UAAU,CAAC;IAClB,yEAAyE;IACzE,OAAO,EAAE,UAAU,CAAC;IACpB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/expressions/hash.d.ts

@@ -0,0 +1,25 @@
+import type { Expression } from './base';
+/** Defines the supported hash types. Includes common cryptographic and non-cryptographic algorithms. */
+export type HashType = 'sha256' | 'sha512' | 'md5' | 'blake3' | 'wyhash' | 'xxh3';
+/**
+ * Defines the encoding for the hash output.
+ * - 'hex': Standard hexadecimal encoding.
+ * - 'base64': Standard base64 encoding.
+ * - 'base64_alphanumeric': Base64 encoding with non-alphanumeric characters (e.g., '+', '/') removed.
+ * - 'base64_alphanumeric_upper': Base64 encoding with non-alphanumeric characters removed and the result converted to uppercase.
+ */
+export type HashEncoding = 'hex' | 'base64' | 'base64_alphanumeric' | 'base64_alphanumeric_upper';
+/** Represents a hashing operation on an expression. */
+export interface HashExpression {
+    /** The specific type of hash algorithm to apply. */
+    type: 'hash';
+    /** The type of hash algorithm to apply. */
+    hashType: HashType;
+    /** The encoding for the output hash string. */
+    encoding: HashEncoding;
+    /** The expression whose value will be hashed. */
+    value: Expression;
+    /** Optional. Minimal number of entropy bits required. Affects encoding, truncating the result to the shortest string with the requested entropy. No error if bits exceed what the hash offers. */
+    bits?: number;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/expressions/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/expressions/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,wGAAwG;AACxG,MAAM,MAAM,QAAQ,GAChB,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,MAAM,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GACpB,KAAK,GACL,QAAQ,GACR,qBAAqB,GACrB,2BAA2B,CAAC;AAEhC,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,QAAQ,EAAE,QAAQ,CAAC;IACnB,+CAA+C;IAC/C,QAAQ,EAAE,YAAY,CAAC;IACvB,iDAAiD;IACjD,KAAK,EAAE,UAAU,CAAC;IAClB,kMAAkM;IAClM,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/expressions/index.d.ts

@@ -0,0 +1,25 @@
+export * from './base';
+export * from './basics';
+export * from './selectors';
+export * from './string';
+export * from './fuzzy';
+export * from './conditional';
+export * from './window';
+export * from './hash';
+export * from './struct';
+export * from './pframes';
+import type { ComparisonExpression, BinaryArithmeticExpression, UnaryArithmeticExpression, CastExpression, BooleanLogicExpression, NotExpression, NullCheckExpression, ColumnReferenceExpression, AxisReferenceExpression, ConstantValueExpression, MinMaxExpression, InSetExpression, AliasExpression } from './basics';
+import type { AllSelectorExpression, StringSelectorExpression, NumericSelectorExpression, IntegerSelectorExpression, FloatSelectorExpression, StartsWithSelectorExpression, EndsWithSelectorExpression, ContainsSelectorExpression, MatchesSelectorExpression, ExcludeSelectorExpression, ByNameSelectorExpression, AxisSelectorExpression, NestedSelectorExpression, SelectorComplementExpression, SelectorUnionExpression, SelectorIntersectionExpression, SelectorDifferenceExpression, SelectorSymmetricDifferenceExpression } from './selectors';
+import type { StringJoinExpression, ExtendedUnaryStringExpression, SubstringExpression, StringReplaceExpression, StringContainsExpression, StringStartsWithExpression, StringEndsWithExpression, StringContainsAnyExpression, StringCountMatchesExpression, StringExtractExpression } from './string';
+import type { StringDistanceExpression, FuzzyStringFilterExpression } from './fuzzy';
+import type { WhenThenOtherwiseExpression, FillNullExpression, FillNaNExpression } from './conditional';
+import type { RankExpression, CumsumExpression, WindowExpression } from './window';
+import type { HashExpression } from './hash';
+import type { StructFieldExpression } from './struct';
+import type { MatchesEcmaRegexExpression, ContainsFuzzyMatchExpression } from './pframes';
+/**
+ * Represents all possible expression types in the system.
+ * This is the main union type that includes all concrete expression implementations.
+ */
+export type Expression = ComparisonExpression | BinaryArithmeticExpression | UnaryArithmeticExpression | CastExpression | BooleanLogicExpression | NotExpression | NullCheckExpression | StringJoinExpression | HashExpression | ColumnReferenceExpression | AxisReferenceExpression | ConstantValueExpression | RankExpression | CumsumExpression | ExtendedUnaryStringExpression | StringDistanceExpression | FuzzyStringFilterExpression | WhenThenOtherwiseExpression | SubstringExpression | StringReplaceExpression | StringContainsExpression | StringStartsWithExpression | StringEndsWithExpression | StringContainsAnyExpression | StringCountMatchesExpression | StringExtractExpression | MinMaxExpression | FillNullExpression | FillNaNExpression | WindowExpression | StructFieldExpression | MatchesEcmaRegexExpression | ContainsFuzzyMatchExpression | InSetExpression | AliasExpression | AllSelectorExpression | StringSelectorExpression | NumericSelectorExpression | IntegerSelectorExpression | FloatSelectorExpression | StartsWithSelectorExpression | EndsWithSelectorExpression | ContainsSelectorExpression | MatchesSelectorExpression | ExcludeSelectorExpression | ByNameSelectorExpression | AxisSelectorExpression | NestedSelectorExpression | SelectorComplementExpression | SelectorUnionExpression | SelectorIntersectionExpression | SelectorDifferenceExpression | SelectorSymmetricDifferenceExpression;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expressions/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAE1B,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,yBAAyB,EACzB,cAAc,EACd,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,eAAe,EACf,eAAe,EAChB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACvB,8BAA8B,EAC9B,4BAA4B,EAC5B,qCAAqC,EACtC,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EACV,oBAAoB,EACpB,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,uBAAuB,EACxB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EACV,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EACV,2BAA2B,EAC3B,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EACV,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,WAAW,CAAC;AAEnB;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB,oBAAoB,GACpB,0BAA0B,GAC1B,yBAAyB,GACzB,cAAc,GACd,sBAAsB,GACtB,aAAa,GACb,mBAAmB,GACnB,oBAAoB,GACpB,cAAc,GACd,yBAAyB,GACzB,uBAAuB,GACvB,uBAAuB,GACvB,cAAc,GACd,gBAAgB,GAChB,6BAA6B,GAC7B,wBAAwB,GACxB,2BAA2B,GAC3B,2BAA2B,GAC3B,mBAAmB,GACnB,uBAAuB,GACvB,wBAAwB,GACxB,0BAA0B,GAC1B,wBAAwB,GACxB,2BAA2B,GAC3B,4BAA4B,GAC5B,uBAAuB,GACvB,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,gBAAgB,GAChB,qBAAqB,GACrB,0BAA0B,GAC1B,4BAA4B,GAC5B,eAAe,GACf,eAAe,GACf,qBAAqB,GACrB,wBAAwB,GACxB,yBAAyB,GACzB,yBAAyB,GACzB,uBAAuB,GACvB,4BAA4B,GAC5B,0BAA0B,GAC1B,0BAA0B,GAC1B,yBAAyB,GACzB,yBAAyB,GACzB,wBAAwB,GACxB,sBAAsB,GACtB,wBAAwB,GACxB,4BAA4B,GAC5B,uBAAuB,GACvB,8BAA8B,GAC9B,4BAA4B,GAC5B,qCAAqC,CAAC"}

package/dist/expressions/pframes.d.ts

@@ -0,0 +1,34 @@
+import type { Expression } from './base';
+/**
+ * Represents a regex matching operation using ECMAScript regular expressions.
+ * Takes a string expression as input and returns a boolean indicating if the input value
+ * matches the provided ECMAScript regular expression.
+ */
+export interface MatchesEcmaRegexExpression {
+    /** The type of operation, always 'matches_ecma_regex'. */
+    type: 'matches_ecma_regex';
+    /** The string expression whose value will be compared. */
+    value: Expression;
+    /** The ECMAScript regular expression to match against. */
+    ecma_regex: string;
+}
+/**
+ * Represents a fuzzy string matching operation.
+ * Takes a string expression as input and returns a boolean indicating if the input value
+ * contains a close match to the provided reference string.
+ */
+export interface ContainsFuzzyMatchExpression {
+    /** The type of operation, always 'contains_fuzzy_match'. */
+    type: 'contains_fuzzy_match';
+    /** The string expression whose value will be compared. */
+    value: Expression;
+    /** The string reference to compare against. */
+    reference: string;
+    /** The maximum number of edits allowed to be considered a match. */
+    max_edits: number;
+    /** The wildcard character to use. */
+    wildcard?: string;
+    /** If true, only substitutions are allowed (deletions and insertions are also allowed by default). */
+    substitutions_only?: boolean;
+}
+//# sourceMappingURL=pframes.d.ts.map

package/dist/expressions/pframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pframes.d.ts","sourceRoot":"","sources":["../../src/expressions/pframes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,0DAA0D;IAC1D,IAAI,EAAE,oBAAoB,CAAC;IAC3B,0DAA0D;IAC1D,KAAK,EAAE,UAAU,CAAC;IAClB,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,4DAA4D;IAC5D,IAAI,EAAE,sBAAsB,CAAC;IAC7B,0DAA0D;IAC1D,KAAK,EAAE,UAAU,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sGAAsG;IACtG,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B"}