@platforma-open/milaboratories.software-ptabler.schema 1.3.0

package/dist/aggregate.d.ts

@@ -0,0 +1,59 @@
+import { Expression, AggregationType } from './expressions';
+/**
+ * Defines standard aggregation functions that operate on a single expression.
+ */
+export type StandardAggregationType = 'sum' | 'mean' | 'median' | 'min' | 'max' | 'std' | 'var' | 'count' | 'first' | 'last' | 'n_unique';
+/**
+ * Defines aggregation functions that select a value from one expression based on the min/max of another expression.
+ */
+export type ByClauseAggregationType = 'max_by' | 'min_by';
+/**
+ * Represents a standard aggregation operation like sum, mean, count, etc.
+ */
+export interface StandardAggregationOperation {
+    /** The name for the resulting column after aggregation. */
+    name: string;
+    /** The type of standard aggregation to perform. */
+    aggregation: AggregationType;
+    /**
+     * The primary expression to aggregate.
+     * For aggregations like 'sum', 'mean', 'min', 'max', this is the expression (e.g., a column) whose values are aggregated.
+     * For 'count', this expression might not be directly used by Polars if counting all rows, but can be used to count non-null values in a specific column.
+     * For 'first', 'last', 'n_unique', this is the expression on which the operation is performed.
+     */
+    expression: Expression;
+}
+/**
+ * Represents an aggregation operation that selects a value from one expression
+ * based on the minimum or maximum value of another expression (the 'by_expression').
+ */
+export interface ByClauseAggregationOperation {
+    /** The name for the resulting column after aggregation. */
+    name: string;
+    /** The type of 'by-clause' aggregation to perform (e.g., 'max_by', 'min_by'). */
+    aggregation: ByClauseAggregationType;
+    /** The expression whose value is selected. */
+    expression: Expression;
+    /**
+     * The expression or list of expressions to order by to determine which value of `expression` is selected.
+     * If an array of expressions is provided, ordering is done sequentially by each expression.
+     */
+    by: Expression[];
+}
+/**
+ * Represents the configuration for an 'aggregate' step in the workflow.
+ * This step performs aggregation operations on a table, optionally grouping by certain columns,
+ * and outputs a new table with the aggregated results.
+ */
+export interface AggregateStep {
+    /** Specifies the type of the step, which is 'aggregate'. */
+    type: 'aggregate';
+    /** The name of the input table from the tablespace on which to perform aggregation. */
+    inputTable: string;
+    /** The name to be assigned to the newly created aggregated table in the tablespace. */
+    outputTable: string;
+    /** An optional list of column names to group by before performing aggregations. */
+    groupBy: string[];
+    /** An array of aggregation operations to apply to the input table. */
+    aggregations: (StandardAggregationOperation | ByClauseAggregationOperation)[];
+}

package/dist/basic_steps.d.ts

@@ -0,0 +1,135 @@
+import { 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.
+ */
+export interface AddColumnsStep {
+    /**
+     * The type identifier for this step.
+     * Must be 'add_columns'.
+     */
+    type: 'add_columns';
+    /**
+     * The name of the target DataFrame in the tablespace to which columns will be added.
+     */
+    table: string;
+    /**
+     * 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;
+    }[];
+}
+/**
+ * Defines a step that filters rows in a table based on a specified condition
+ * and outputs the result to a new table in the tablespace.
+ */
+export interface FilterStep {
+    /**
+     * The type identifier for this step.
+     * Must be 'filter'.
+     */
+    type: 'filter';
+    /**
+     * The name of the input table in the tablespace from which rows will be filtered.
+     */
+    inputTable: string;
+    /**
+     * The name for the resulting filtered table that will be added to the tablespace.
+     * This new table will contain only the rows that satisfy the condition.
+     */
+    outputTable: string;
+    /**
+     * A boolean Expression object used as the filter condition.
+     * Rows for which this expression evaluates to true are kept in the outputTable.
+     * Rows for which it evaluates to false or null are excluded.
+     */
+    condition: Expression;
+}
+/**
+ * Defines a step that selects a specific set of columns from an input table,
+ * potentially applying transformations or creating new columns, and outputs
+ * the result to a new table in the tablespace. This operation is similar
+ * to Polars' `select` method.
+ */
+export interface SelectStep {
+    /**
+     * The type identifier for this step.
+     * Must be 'select'.
+     */
+    type: 'select';
+    /**
+     * The name of the input table in the tablespace from which columns will be selected.
+     */
+    inputTable: string;
+    /**
+     * The name for the resulting table that will be added to the tablespace.
+     * This new table will contain only the columns defined in the 'columns' array.
+     */
+    outputTable: string;
+    /**
+     * An array defining the columns for the output table.
+     * 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;
+    }[];
+}
+/**
+ * Defines a step that adds new columns to an input table (or replaces existing ones
+ * if names collide) and outputs the result to a new table in the tablespace.
+ * This operation is similar to Polars' `with_columns` method.
+ */
+export interface WithColumnsStep {
+    /**
+     * The type identifier for this step.
+     * Must be 'with_columns'.
+     */
+    type: 'with_columns';
+    /**
+     * The name of the input table in the tablespace to which columns will be added.
+     */
+    inputTable: string;
+    /**
+     * The name for the resulting table that will be added to the tablespace.
+     * This new table will contain all original columns from the inputTable,
+     * plus the new columns defined here (or with existing columns replaced by
+     * new ones if names match).
+     */
+    outputTable: string;
+    /**
+     * An array defining the new or replacement columns.
+     * 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;
+    }[];
+}

package/dist/common.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Defines the supported Polars primitive data types for schema definition.
+ *
+ * The following are aliases for convenience:
+ * - 'Int': maps to 'Int32'
+ * - 'Long': maps to 'Int64'
+ * - 'Float': maps to 'Float32'
+ * - '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';

package/dist/concatenate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Defines a step that vertically concatenates multiple tables from the tablespace
+ * into a single output table. Columns are matched by name.
+ */
+export interface ConcatenateStep {
+    /** The type identifier for this step. Must be 'concatenate'. */
+    type: 'concatenate';
+    /**
+     * An array of input table names from the tablespace.
+     * The tables are concatenated vertically in the order they appear in this array.
+     */
+    inputTables: string[];
+    /** The name to be assigned to the newly created concatenated table in the tablespace. */
+    outputTable: string;
+    /**
+     * Optional. A list of column names to select from all input tables.
+     * If omitted, all columns from all input tables are included, and columns are matched by name.
+     * If provided, only these specified columns will be included in the output table.
+     * All input tables must contain all specified columns for the operation to succeed.
+     */
+    columns?: string[];
+}

package/dist/expressions.d.ts

@@ -0,0 +1,320 @@
+import { DataType } from './common';
+export type Expression = ComparisonExpression | BinaryArithmeticExpression | UnaryArithmeticExpression | CastExpression | BooleanLogicExpression | NotExpression | NullCheckExpression | StringJoinExpression | HashExpression | ColumnReferenceExpression | ConstantValueExpression | RankExpression | CumsumExpression | ExtendedUnaryStringExpression | StringDistanceExpression | FuzzyStringFilterExpression | WhenThenOtherwiseExpression | SubstringExpression | StringReplaceExpression | MinMaxExpression | FillNaExpression | WindowExpression;
+/** Represents all possible expression types in the system. */
+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 string join operation on an array of expressions. */
+export interface StringJoinExpression {
+    /** The type of operation, always 'str_join'. */
+    type: 'str_join';
+    /** An array of expressions whose string representations will be joined. */
+    operands: Expression[];
+    /** An optional delimiter string to insert between joined elements. */
+    delimiter?: string;
+}
+/** 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;
+}
+/** 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 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;
+}
+/**
+ * Represents a rank function applied over a dataset partition.
+ * Calculates the rank of each row within its partition based on the specified ordering.
+ */
+export interface RankExpression {
+    /** The type of operation, always 'rank'. */
+    type: 'rank';
+    /** List of expressions to partition the data by before ranking. The output of these expressions will be used for partitioning. */
+    partitionBy: Expression[];
+    /** Defines the ordering expressions within partitions to determine the rank. */
+    orderBy: Expression[];
+    /** Whether to sort in descending order. Defaults to false (ascending). */
+    descending?: boolean;
+}
+/**
+ * Represents a cumulative sum function applied over a dataset partition.
+ * Calculates the cumulative sum of the 'value' expression within each partition,
+ * based on the specified ordering. Values are sorted by value and then by
+ * additional_order_by before summing.
+ */
+export interface CumsumExpression {
+    /** The type of operation, always 'cumsum'. */
+    type: 'cumsum';
+    /** The expression whose values will be cumulatively summed. */
+    value: Expression;
+    /** Defines additional ordering within partitions for the cumulative sum calculation, in addition to the ordering of the values themselves. */
+    additionalOrderBy: Expression[];
+    /** List of expressions to partition the data by before calculating the cumulative sum. The output of these expressions will be used for partitioning. */
+    partitionBy: Expression[];
+    /** Whether to sort in descending order. Defaults to false (ascending). */
+    descending?: boolean;
+}
+/** Defines the supported unary string operators. */
+export type UnaryStringOperator = 'to_upper' | 'to_lower';
+/** Represents a unary string operation on a single expression. */
+export interface ExtendedUnaryStringExpression {
+    /** The type of unary string operation (e.g., 'to_upper', 'to_lower', 'str_len'). */
+    type: UnaryStringOperator | 'str_len';
+    /** The string expression to operate on. */
+    value: Expression;
+}
+/** 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;
+}
+/**
+ * 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 substring extraction operation on an expression.
+ * Extracts a portion of the string value resulting from the 'value' expression.
+ * The substring starts at the 'start' index (0-based).
+ * - If 'length' is provided, it specifies the maximum length of the substring.
+ * - If 'end' is provided, it specifies the index *before* which the substring ends.
+ * - If neither 'length' nor 'end' is provided, the substring extends to the end of the string.
+ * - 'length' and 'end' are mutually exclusive.
+ * If the requested substring range extends beyond the actual string length,
+ * the extraction automatically stops at the end of the string.
+ */
+export interface SubstringExpression {
+    /** The type of operation, always 'substring'. */
+    type: 'substring';
+    /** The expression whose string value will be used. */
+    value: Expression;
+    /** The starting position (0-indexed). */
+    start: number;
+    /** The length of the substring. Mutually exclusive with 'end'. */
+    length?: number;
+    /** The end position of the substring (exclusive). Mutually exclusive with 'length'. */
+    end?: number;
+}
+/**
+ * Represents a string replacement operation.
+ * Replaces occurrences of a pattern (regex or literal) in a string expression with a replacement string.
+ * The behavior is aligned with Polars' `replace` and `replace_all` functions.
+ *
+ * - If `literal` is true, the `pattern` is treated as a literal string. Otherwise, it's treated as a regular expression.
+ * - If `replaceAll` is true, all occurrences of the pattern are replaced. Otherwise, only the first occurrence is replaced.
+ *
+ * When using regular expressions (i.e., `literal` is false or undefined):
+ * - Positional capture groups can be referenced in the `replacement` string using `$n` or `${n}` (e.g., `$1` for the first group).
+ * - Named capture groups can be referenced using `${name}`.
+ * - To include a literal dollar sign (`$`) in the replacement, it must be escaped as `$$`.
+ */
+export interface StringReplaceExpression {
+    /** The type of operation, always 'str_replace'. */
+    type: 'str_replace';
+    /** The input string expression to operate on. */
+    value: Expression;
+    /** The pattern (regex or literal string) to search for. Can be a string literal or an expression evaluating to a string. */
+    pattern: Expression | string;
+    /** The replacement string. Can be a string literal or an expression evaluating to a string. Can use $n or ${name} for captured groups if pattern is a regex. */
+    replacement: Expression | string;
+    /** If true, replace all occurrences of the pattern. If false or undefined, replace only the first. Defaults to false. */
+    replaceAll?: boolean;
+    /** If true, treat the pattern as a literal string. If false or undefined, treat it as a regex. Defaults to false. */
+    literal?: boolean;
+}
+/** 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 a fill NA (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_na(input), fillValue).otherwise(input)).
+ */
+export interface FillNaExpression {
+    /** The type of operation, always 'fill_na'. */
+    type: 'fill_na';
+    /** The primary expression to evaluate. */
+    input: Expression;
+    /** The expression whose value is used if 'input' is null. */
+    fillValue: Expression;
+}
+/**
+ * Defines standard aggregation functions that can be used in window expressions.
+ */
+export type AggregationType = 'sum' | 'mean' | 'median' | 'min' | 'max' | 'std' | 'var' | 'count' | 'first' | 'last' | 'n_unique';
+/**
+ * Represents a window function call.
+ * This allows applying an aggregation function over a specific partition of the data.
+ */
+export interface WindowExpression {
+    /** The type of operation, always 'aggregate'. Note: This might be confusing, consider 'window_aggregate' or similar if 'aggregate' is heavily used elsewhere for a different step type. */
+    type: 'aggregate';
+    /** The aggregation function to apply (e.g., 'sum', 'mean'). */
+    aggregation: AggregationType;
+    /** The expression to apply the aggregation function to. */
+    value: Expression;
+    /** List of expressions to partition the data by. The aggregation is performed independently within each partition. */
+    partitionBy: Expression[];
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { ReadCsvStep, WriteCsvStep } from './io';
+import { AddColumnsStep, FilterStep } from './basic_steps';
+import { AggregateStep } from './aggregate';
+import { AnyJoinStep } from './join';
+import { ConcatenateStep } from './concatenate';
+import { SortStep } from './sort';
+export type PTablerStep = ReadCsvStep | WriteCsvStep | AddColumnsStep | FilterStep | AggregateStep | AnyJoinStep | ConcatenateStep | SortStep;
+export type PTablerWorkflow = {
+    workflow: PTablerStep[];
+};

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/io.d.ts

@@ -0,0 +1,68 @@
+import { DataType } from './common';
+/**
+ * Represents the schema definition for a single column.
+ */
+export interface ColumnSchema {
+    /** The name of the column. */
+    column: string;
+    /** Optional: The expected Polars data type for this column. */
+    type?: DataType;
+    /** Optional: A specific string to be interpreted as a null value for this column. */
+    nullValue?: string;
+}
+/** Represents the configuration for a step that reads data from a CSV file into the tablespace. */
+export interface ReadCsvStep {
+    /** The type of the step, which is always 'read_csv' for this operation. */
+    type: 'read_csv';
+    /** Path to the CSV file to be read. */
+    file: string;
+    /** The name assigned to the loaded DataFrame in the tablespace. */
+    name: string;
+    /** Optional: The delimiter character used in the CSV file. */
+    delimiter?: string;
+    /**
+     * Optional: Provides schema information for specific columns.
+     * If `infer_schema` is `true` (default), these definitions act as overrides
+     * to the types inferred by Polars. Each `ColumnSchema` can specify a `type`
+     * and/or a `nullValue`. If `infer_schema` is `false`, these definitions are
+     * used directly; for columns not listed, Polars' default behavior when no
+     * type is specified (e.g., reading as string) will apply.
+     */
+    schema?: ColumnSchema[];
+    /**
+     * Optional: Whether to infer the schema from the CSV file using Polars'
+     * default inference mechanism (e.g., reading a certain number of rows).
+     * Defaults to `true`. If set to `false`, type inference is disabled,
+     * and types will rely on the `schema` field or Polars' defaults for
+     * columns not specified in `schema`.
+     */
+    infer_schema?: boolean;
+}
+/**
+ * Represents the configuration for a step that writes a table from the tablespace to a CSV file.
+ */
+export interface WriteCsvStep {
+    /** The type of the step, which is always 'write_csv' for this operation. */
+    type: 'write_csv';
+    /** The name of the table in the tablespace to be written. */
+    table: string;
+    /** Path to the output CSV file. */
+    file: string;
+    /** Optional: A list of column names to write to the CSV. If omitted, all columns are written. */
+    columns?: string[];
+    /** Optional: The delimiter character to use in the output CSV file. */
+    delimiter?: string;
+}
+/**
+ * Represents the configuration for a step that writes a table from the tablespace to a JSON file.
+ */
+export interface WriteJsonStep {
+    /** The type of the step, which is always 'write_json' for this operation. */
+    type: 'write_json';
+    /** The name of the table in the tablespace to be written. */
+    table: string;
+    /** Path to the output JSON file. */
+    file: string;
+    /** Optional: A list of column names to write to the JSON. If omitted, all columns are written. */
+    columns?: string[];
+}