ts-prorm-orm 1.1.0 → 1.2.0

package/dist/models/data-types.d.ts

@@ -0,0 +1,1656 @@
+/**
+ * Data Types for the ORM
+ * Provides all standard data types with proper class implementations
+ */
+import { DataType, DataTypeAbstract } from '../types';
+/**
+ * Base class for all data types
+ */
+declare abstract class AbstractDataType implements DataTypeAbstract {
+    abstract key: string;
+    toSqlString(dialect?: string): string;
+    toSQL(): string;
+    toSql(): string;
+    /**
+     * Compare this DataType with another DataType for equality
+     * @param other - The DataType to compare with
+     * @returns true if the types are equal, false otherwise
+     */
+    equals(other: DataTypeAbstract): boolean;
+    /**
+     * Serialize a value for storage based on this DataType
+     * @param value - The value to serialize
+     * @returns The serialized value
+     */
+    serialize(value: unknown): unknown;
+}
+declare class STRING extends AbstractDataType {
+    key: "STRING";
+    length?: number;
+    binary?: boolean;
+    /**
+     * Create a STRING data type
+     * @param length - Optional length (1-65535). If not provided, defaults to TEXT
+     * @param binary - Whether to use BINARY collation
+     * @example
+     * // STRING with length (VARCHAR)
+     * DataTypes.STRING(100)  // VARCHAR(100)
+     * // STRING without length (TEXT)
+     * DataTypes.STRING       // TEXT
+     */
+    constructor(length?: number, binary?: boolean);
+    toSqlString(): string;
+}
+declare class VARCHAR extends AbstractDataType {
+    key: "VARCHAR";
+    length: number;
+    binary?: boolean;
+    constructor(length?: number, binary?: boolean);
+    toSqlString(): string;
+}
+declare class CHAR extends AbstractDataType {
+    key: "CHAR";
+    length: number;
+    binary?: boolean;
+    constructor(length?: number);
+    toSqlString(): string;
+}
+declare class TEXT extends AbstractDataType {
+    key: "TEXT";
+    length?: 'tiny' | 'medium' | 'long';
+    constructor(length?: 'tiny' | 'medium' | 'long');
+    /**
+     * Get the TEXT type string based on length variant for MySQL/MariaDB
+     */
+    private getTextType;
+    toSqlString(dialect?: string): string;
+}
+declare class TINYTEXT extends AbstractDataType {
+    key: "TINYTEXT";
+    toSqlString(dialect?: string): string;
+}
+declare class MEDIUMTEXT extends AbstractDataType {
+    key: "MEDIUMTEXT";
+    toSqlString(dialect?: string): string;
+}
+declare class LONGTEXT extends AbstractDataType {
+    key: "LONGTEXT";
+    toSqlString(dialect?: string): string;
+}
+declare abstract class AbstractIntegerType extends AbstractDataType {
+    abstract key: string;
+    length?: number;
+    unsigned?: boolean;
+    zerofill?: boolean;
+    /**
+     * Set as unsigned
+     * @example
+     * DataTypes.INTEGER.UNSIGNED()
+     * DataTypes.BIGINT.UNSIGNED()
+     */
+    UNSIGNED(): this;
+    /**
+     * Set as zerofill
+     * @example
+     * DataTypes.INTEGER.ZEROFILL()
+     * DataTypes.INTEGER.UNSIGNED().ZEROFILL()
+     */
+    ZEROFILL(): this;
+    /**
+     * Generate SQL string with unsigned and zerofill options
+     */
+    protected toSqlStringHelper(baseType: string): string;
+}
+declare class INTEGER extends AbstractIntegerType {
+    key: "INTEGER";
+    constructor(options?: {
+        length?: number;
+        unsigned?: boolean;
+        zerofill?: boolean;
+    });
+    toSqlString(): string;
+}
+declare class TINYINT extends AbstractIntegerType {
+    key: "TINYINT";
+    /**
+     * Create a TINYINT data type
+     * @param options - Optional options object
+     * @example
+     * // Simple TINYINT
+     * DataTypes.TINYINT()
+     * // TINYINT with options
+     * DataTypes.TINYINT({ unsigned: true })
+     * // Using chainable methods
+     * DataTypes.TINYINT().UNSIGNED()
+     * DataTypes.TINYINT().ZEROFILL()
+     */
+    constructor(options?: {
+        length?: number;
+        unsigned?: boolean;
+        zerofill?: boolean;
+    });
+    toSqlString(): string;
+}
+declare class SMALLINT extends AbstractIntegerType {
+    key: "SMALLINT";
+    /**
+     * Create a SMALLINT data type
+     * @param options - Optional options object
+     * @example
+     * // Simple SMALLINT
+     * DataTypes.SMALLINT()
+     * // SMALLINT with options
+     * DataTypes.SMALLINT({ unsigned: true })
+     * // Using chainable methods
+     * DataTypes.SMALLINT().UNSIGNED()
+     * DataTypes.SMALLINT().ZEROFILL()
+     */
+    constructor(options?: {
+        length?: number;
+        unsigned?: boolean;
+        zerofill?: boolean;
+    });
+    toSqlString(): string;
+}
+declare class MEDIUMINT extends AbstractIntegerType {
+    key: "MEDIUMINT";
+    /**
+     * Create a MEDIUMINT data type
+     * @param options - Optional options object
+     * @example
+     * // Simple MEDIUMINT
+     * DataTypes.MEDIUMINT()
+     * // MEDIUMINT with options
+     * DataTypes.MEDIUMINT({ unsigned: true })
+     * // Using chainable methods
+     * DataTypes.MEDIUMINT().UNSIGNED()
+     * DataTypes.MEDIUMINT().ZEROFILL()
+     */
+    constructor(options?: {
+        length?: number;
+        unsigned?: boolean;
+        zerofill?: boolean;
+    });
+    toSqlString(): string;
+}
+declare class BIGINT extends AbstractIntegerType {
+    key: "BIGINT";
+    /**
+     * Create a BIGINT data type
+     * @param options - Optional options object
+     * @example
+     * // Simple BIGINT
+     * DataTypes.BIGINT()
+     * // BIGINT with options
+     * DataTypes.BIGINT({ unsigned: true })
+     * // Using chainable methods
+     * DataTypes.BIGINT().UNSIGNED()
+     * DataTypes.BIGINT().ZEROFILL()
+     */
+    constructor(options?: {
+        length?: number;
+        unsigned?: boolean;
+        zerofill?: boolean;
+    });
+    toSqlString(): string;
+}
+declare class FLOAT extends AbstractDataType {
+    key: "FLOAT";
+    /**
+     * Precision (total number of digits)
+     */
+    precision?: number;
+    /**
+     * Number of decimal places
+     */
+    decimals?: number;
+    /**
+     * Whether the value is unsigned
+     */
+    unsigned?: boolean;
+    /**
+     * Create a FLOAT data type
+     * @param precisionOrOptions - Either a precision number or an options object
+     * @example
+     * // Simple FLOAT
+     * DataTypes.FLOAT()
+     * // FLOAT with precision
+     * DataTypes.FLOAT(8)
+     * // FLOAT with options
+     * DataTypes.FLOAT({ precision: 8, decimals: 2, unsigned: true })
+     */
+    constructor(precisionOrOptions?: number | {
+        precision?: number;
+        decimals?: number;
+        unsigned?: boolean;
+    });
+    toSqlString(dialect?: string): string;
+}
+declare class DOUBLE extends AbstractDataType {
+    key: "DOUBLE";
+    /**
+     * Precision (total number of digits) - MySQL/MariaDB specific
+     */
+    precision?: number;
+    /**
+     * Number of decimal places
+     */
+    decimals?: number;
+    /**
+     * Whether the value is unsigned
+     */
+    unsigned?: boolean;
+    /**
+     * Create a DOUBLE data type
+     * @param precisionOrOptions - Either a precision number or an options object
+     * @example
+     * // Simple DOUBLE
+     * DataTypes.DOUBLE()
+     * // DOUBLE with precision (MySQL/MariaDB)
+     * DataTypes.DOUBLE(16)
+     * // DOUBLE with options (backward compatibility)
+     * DataTypes.DOUBLE({ precision: 16, decimals: 4, unsigned: true })
+     */
+    constructor(precisionOrOptions?: number | {
+        precision?: number;
+        decimals?: number;
+        unsigned?: boolean;
+    });
+    toSqlString(dialect?: string): string;
+}
+declare class DECIMAL extends AbstractDataType {
+    key: "DECIMAL";
+    /**
+     * Total number of digits (precision)
+     */
+    precision: number;
+    /**
+     * Number of digits after the decimal point (scale)
+     */
+    scale: number;
+    /**
+     * Whether the value is unsigned (MySQL/MariaDB only)
+     */
+    unsigned?: boolean;
+    /**
+     * Create a DECIMAL data type
+     * @param precisionOrOptions - Either precision number or an options object
+     * @param scale - Number of decimal places (when precision is a number)
+     * @param unsigned - Whether the value is unsigned
+     * @example
+     * // DECIMAL with default precision (10, 0)
+     * DataTypes.DECIMAL()
+     * // DECIMAL with precision only (scale defaults to 0)
+     * DataTypes.DECIMAL(10)
+     * // DECIMAL with precision and scale
+     * DataTypes.DECIMAL(10, 2)
+     * // DECIMAL with options object
+     * DataTypes.DECIMAL({ precision: 10, scale: 2, unsigned: true })
+     */
+    constructor(precisionOrOptions?: number | {
+        precision?: number;
+        scale?: number;
+        unsigned?: boolean;
+    }, scale?: number, unsigned?: boolean);
+    toSqlString(dialect?: string): string;
+}
+declare class BOOLEAN extends AbstractDataType {
+    key: "BOOLEAN";
+    toSqlString(): string;
+}
+declare class DATE extends AbstractDataType {
+    key: "DATE";
+    precision?: number;
+    timezone?: boolean;
+    constructor(precision?: number, timezone?: boolean);
+    toSqlString(dialect?: string): string;
+}
+declare class DATEONLY extends AbstractDataType {
+    key: "DATEONLY";
+    toSqlString(dialect?: string): string;
+}
+declare class TIME extends AbstractDataType {
+    key: "TIME";
+    precision?: number;
+    timezone?: boolean;
+    constructor(precision?: number, timezone?: boolean);
+    toSqlString(dialect?: string): string;
+}
+declare class REAL extends AbstractDataType {
+    key: "REAL";
+    /**
+     * Precision (total number of digits) - MySQL/MariaDB specific
+     */
+    precision?: number;
+    /**
+     * Number of decimal places
+     */
+    decimals?: number;
+    /**
+     * Whether the value is unsigned (MySQL/MariaDB only)
+     */
+    unsigned?: boolean;
+    /**
+     * Create a REAL data type
+     * @param precisionOrOptions - Either a precision number or an options object
+     * @example
+     * // Simple REAL
+     * DataTypes.REAL()
+     * // REAL with precision (MySQL/MariaDB)
+     * DataTypes.REAL(10)
+     * // REAL with options
+     * DataTypes.REAL({ precision: 10, decimals: 2, unsigned: true })
+     */
+    constructor(precisionOrOptions?: number | {
+        precision?: number;
+        decimals?: number;
+        unsigned?: boolean;
+    });
+    toSqlString(dialect?: string): string;
+}
+declare class TIMESTAMP extends AbstractDataType {
+    key: "TIMESTAMP";
+    precision?: number;
+    constructor(precision?: number);
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the current timestamp SQL for use as a default value
+     */
+    toDefaultValue(dialect?: string): string;
+}
+declare class DATETIME extends AbstractDataType {
+    key: "DATETIME";
+    precision?: number;
+    constructor(precision?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class UUID extends AbstractDataType {
+    key: "UUID";
+    toSqlString(dialect?: string): string;
+}
+declare class UUIDV4 extends AbstractDataType {
+    key: "UUIDV4";
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the default value for UUIDV4 - generates a new UUID v4 string
+     * This is called by the dialect when using UUIDV4 as a defaultValue
+     */
+    toDefaultValue(_dialect?: string): string;
+    /**
+     * Generate a UUID v4 string (instance method)
+     */
+    generate(): string;
+    /**
+     * Generate a UUID v4 string (static method)
+     */
+    static generate(): string;
+}
+declare class UUIDV1 extends AbstractDataType {
+    key: "UUIDV1";
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the default value for UUIDV1 - generates a new UUID v1 string
+     * This is called by the dialect when using UUIDV1 as a defaultValue
+     */
+    toDefaultValue(_dialect?: string): string;
+    /**
+     * Generate a UUID v1 string (instance method)
+     */
+    generate(): string;
+    /**
+     * Generate a time-based UUID v1 string (static method)
+     * Note: This is a simplified, structurally-valid v1 UUID (RFC 4122 layout:
+     * time_low-time_mid-time_hi_and_version-clock_seq-node) derived from the
+     * current timestamp. It does not track a persistent MAC address or clock
+     * sequence across calls, which is acceptable for use as a unique row id.
+     */
+    static generate(): string;
+}
+declare class NOW extends AbstractDataType {
+    key: "NOW";
+    /**
+     * Optional precision for fractional seconds
+     */
+    precision?: number;
+    constructor(precision?: number);
+    /**
+     * Get the current timestamp SQL for use as default value
+     * This returns the raw SQL function name that gets passed through
+     * without quotes in the defaultValue handling
+     */
+    toDefaultValue(dialect?: string): string;
+    toSqlString(dialect?: string): string;
+}
+/**
+ * JSON - standard JSON (text-based)
+ * - PostgreSQL: native JSON type
+ * - MySQL/MariaDB: native JSON type
+ * - SQLite: TEXT with JSON handling
+ *
+ * @example
+ * // Use native JSON where supported
+ * metadata: DataTypes.JSON(true)
+ * // Use TEXT fallback (useful for SQLite compatibility)
+ * settings: DataTypes.JSON(false) // or DataTypes.JSON()
+ */
+declare class JSON extends AbstractDataType {
+    key: "JSON";
+    /**
+     * Whether to use native JSON type or store as TEXT
+     * - true: Use native JSON type where supported
+     * - false: Always use TEXT (useful for SQLite or when JSON is not supported)
+     */
+    useNative: boolean;
+    constructor(useNative?: boolean);
+    toSqlString(dialect?: string): string;
+}
+/**
+ * JSONB - binary JSON (PostgreSQL native)
+ * - PostgreSQL: native JSONB type (binary format, indexed)
+ * - MySQL/MariaDB: TEXT with JSON handling (no native JSONB)
+ * - SQLite: TEXT with JSON handling
+ *
+ * Benefits of JSONB in PostgreSQL:
+ * - Binary storage format (faster parsing)
+ * - Supports indexing with GIN
+ * - Key existence operators (? &?| etc.)
+ *
+ * @example
+ * // Use native JSONB for PostgreSQL, TEXT for others
+ * settings: DataTypes.JSONB()
+ * // or DataTypes.JSONB(true)
+ *
+ * // Always use TEXT (useful when JSONB features not needed)
+ * metadata: DataTypes.JSONB(false)
+ */
+declare class JSONB extends AbstractDataType {
+    key: "JSONB";
+    /**
+     * Whether to use native JSONB type or store as TEXT
+     * - true: Use native JSONB for PostgreSQL, TEXT for others
+     * - false: Always use TEXT (useful for SQLite/MySQL compatibility)
+     */
+    useNative: boolean;
+    constructor(useNative?: boolean);
+    toSqlString(dialect?: string): string;
+}
+declare class HSTORE extends AbstractDataType {
+    key: "HSTORE";
+    /**
+     * Whether to use native HStore or JSONB fallback
+     */
+    useNative: boolean;
+    constructor(useNative?: boolean);
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the SQL to create the HStore extension (PostgreSQL)
+     */
+    static getExtensionSQL(): string;
+}
+declare class RANGE extends AbstractDataType {
+    key: "RANGE";
+    subtype: string;
+    constructor(subtype?: 'int4range' | 'int8range' | 'numrange' | 'tsrange' | 'tstzrange' | 'daterange');
+    toSqlString(dialect?: string): string;
+}
+declare class INET extends AbstractDataType {
+    key: "INET";
+    version: 4 | 6;
+    constructor(options?: {
+        version?: 4 | 6;
+    } | 4 | 6);
+    toSqlString(dialect?: string): string;
+}
+declare class CIDR extends AbstractDataType {
+    key: "CIDR";
+    toSqlString(dialect?: string): string;
+}
+declare class MACADDR extends AbstractDataType {
+    key: "MACADDR";
+    toSqlString(dialect?: string): string;
+}
+declare class BINARY extends AbstractDataType {
+    key: "BINARY";
+    length: number;
+    constructor(length?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class VARBINARY extends AbstractDataType {
+    key: "VARBINARY";
+    length: number;
+    constructor(length?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class BLOB extends AbstractDataType {
+    key: "BLOB";
+    length?: 'tiny' | 'medium' | 'long';
+    constructor(length?: 'tiny' | 'medium' | 'long');
+    /**
+     * Get the BLOB type string based on length variant
+     * MySQL/MariaDB format: TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB
+     */
+    private getBlobType;
+    toSqlString(dialect?: string): string;
+}
+declare class TINYBLOB extends AbstractDataType {
+    key: "TINYBLOB";
+    toSqlString(dialect?: string): string;
+}
+declare class MEDIUMBLOB extends AbstractDataType {
+    key: "MEDIUMBLOB";
+    toSqlString(dialect?: string): string;
+}
+declare class LONGBLOB extends AbstractDataType {
+    key: "LONGBLOB";
+    toSqlString(dialect?: string): string;
+}
+declare class ENUM extends AbstractDataType {
+    key: "ENUM";
+    values: string[];
+    /**
+     * Optional name for the enum type (useful for PostgreSQL/MySQL)
+     */
+    name?: string;
+    /**
+     * Create an ENUM data type
+     * @param values - Either an array of values or individual string values
+     * @example
+     * // Array of values
+     * DataTypes.ENUM(['active', 'inactive', 'pending'])
+     * // Individual values
+     * DataTypes.ENUM('active', 'inactive', 'pending')
+     */
+    constructor(...values: (string | string[])[]);
+    /**
+     * Set a name for the enum type (useful for PostgreSQL/MySQL)
+     */
+    setName(name: string): this;
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the values for validation
+     */
+    getValues(): string[];
+    /**
+     * Validate if a value is valid for this ENUM
+     */
+    validate(value: string): boolean;
+    /**
+     * Generate an ALTER TABLE statement to add/modify ENUM column
+     * Note: MySQL uses MODIFY COLUMN, PostgreSQL needs type recreation
+     */
+    toAlterTableSql(dialect: string, tableName: string, columnName: string, _columnDefinition?: string): string;
+}
+declare class ARRAY extends AbstractDataType {
+    key: "ARRAY";
+    /**
+     * The element type of the array (e.g., STRING, INTEGER, etc.)
+     */
+    type: AbstractDataType;
+    /**
+     * Create an ARRAY data type
+     * @param type - The data type of array elements
+     * @example
+     * // Array of strings
+     * tags: DataTypes.ARRAY(DataTypes.STRING)
+     * // Array of integers
+     * numbers: DataTypes.ARRAY(DataTypes.INTEGER)
+     * // Array of floats
+     * prices: DataTypes.ARRAY(DataTypes.FLOAT)
+     */
+    constructor(type: AbstractDataType);
+    /**
+     * Get the SQL string representation based on the dialect
+     * PostgreSQL: Uses native array syntax (e.g., TEXT[], INTEGER[])
+     * Other dialects: Falls back to JSON or TEXT
+     */
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the element type
+     */
+    getElementType(): AbstractDataType;
+}
+declare class LIST extends AbstractDataType {
+    key: "LIST";
+    /**
+     * The element type of the list (e.g., STRING, INTEGER, another LIST, etc.)
+     */
+    type: AbstractDataType;
+    /**
+     * Create a LIST data type
+     * @param type - The data type of list elements
+     * @example
+     * // List of integers (DuckDB: INTEGER[])
+     * tags: DataTypes.LIST(DataTypes.INTEGER)
+     * // Nested list (DuckDB: VARCHAR[][])
+     * matrix: DataTypes.LIST(DataTypes.LIST(DataTypes.VARCHAR))
+     */
+    constructor(type: AbstractDataType);
+    /**
+     * Get the SQL string representation based on the dialect
+     * DuckDB/PostgreSQL: native `elementType[]` syntax
+     * Other dialects: falls back to JSON or TEXT
+     */
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the element type
+     */
+    getElementType(): AbstractDataType;
+}
+declare class STRUCT extends AbstractDataType {
+    key: "STRUCT";
+    /**
+     * The named fields of the struct, in insertion order
+     */
+    fields: Record<string, AbstractDataType>;
+    /**
+     * Create a STRUCT data type
+     * @param fields - A map of field name -> field data type
+     * @example
+     * // DuckDB: STRUCT(x INTEGER, y INTEGER)
+     * point: DataTypes.STRUCT({ x: DataTypes.INTEGER, y: DataTypes.INTEGER })
+     */
+    constructor(fields: Record<string, AbstractDataType>);
+    /**
+     * Get the SQL string representation based on the dialect
+     * DuckDB: native `STRUCT(field TYPE, ...)` syntax
+     * Other dialects: falls back to JSON or TEXT
+     */
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the struct's fields
+     */
+    getFields(): Record<string, AbstractDataType>;
+}
+declare class MAP extends AbstractDataType {
+    key: "MAP";
+    /**
+     * The data type of map keys
+     */
+    keyType: AbstractDataType;
+    /**
+     * The data type of map values
+     */
+    valueType: AbstractDataType;
+    /**
+     * Create a MAP data type
+     * @param keyType - The data type of map keys
+     * @param valueType - The data type of map values
+     * @example
+     * // DuckDB: MAP(VARCHAR, INTEGER)
+     * scores: DataTypes.MAP(DataTypes.STRING, DataTypes.INTEGER)
+     */
+    constructor(keyType: AbstractDataType, valueType: AbstractDataType);
+    /**
+     * Get the SQL string representation based on the dialect
+     * DuckDB: native `MAP(keyType, valueType)` syntax
+     * Other dialects: falls back to JSON or TEXT
+     */
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the map's key type
+     */
+    getKeyType(): AbstractDataType;
+    /**
+     * Get the map's value type
+     */
+    getValueType(): AbstractDataType;
+}
+declare class DUCKDB_UNION extends AbstractDataType {
+    key: "UNION";
+    /**
+     * The named member alternatives of the union, in insertion order
+     */
+    fields: Record<string, AbstractDataType>;
+    /**
+     * Create a UNION data type
+     * @param fields - A map of tag name -> alternative data type
+     * @example
+     * // DuckDB: UNION(num INTEGER, str VARCHAR)
+     * value: DataTypes.UNION({ num: DataTypes.INTEGER, str: DataTypes.STRING })
+     */
+    constructor(fields: Record<string, AbstractDataType>);
+    /**
+     * Get the SQL string representation based on the dialect
+     * DuckDB: native `UNION(tag TYPE, ...)` syntax
+     * Other dialects: falls back to JSON or TEXT
+     */
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the union's member fields
+     */
+    getFields(): Record<string, AbstractDataType>;
+}
+export type GeometryType = 'POINT' | 'LINESTRING' | 'POLYGON' | 'MULTIPOINT' | 'MULTILINESTRING' | 'MULTIPOLYGON' | 'GEOMETRYCOLLECTION' | 'GEOMETRY';
+/**
+ * Geometry - for spatial/geometric data
+ * Supports optional geometry type and SRID (Spatial Reference System Identifier)
+ *
+ * @example
+ * // Basic geometry (stored as JSON/text)
+ * location: DataTypes.GEOMETRY
+ *
+ * // Geometry with specific type
+ * point: DataTypes.GEOMETRY('POINT')
+ * line: DataTypes.GEOMETRY('LINESTRING')
+ * area: DataTypes.GEOMETRY('POLYGON')
+ *
+ * // Geometry with type and SRID (coordinate system)
+ * geoPoint: DataTypes.GEOMETRY('POINT', 4326)
+ */
+declare class GEOMETRY extends AbstractDataType {
+    key: "GEOMETRY";
+    /**
+     * The geometry type (POINT, LINESTRING, POLYGON, etc.)
+     */
+    type?: GeometryType;
+    /**
+     * SRID (Spatial Reference System Identifier) for the coordinate system
+     * Common values:
+     * - 4326: WGS 84 (GPS coordinates)
+     * - 3857: Web Mercator (Google Maps, OpenStreetMap)
+     * - 326xx: UTM zones (e.g., 32618 for UTM Zone 18N)
+     */
+    srid?: number;
+    constructor(type?: GeometryType, srid?: number);
+    constructor(options?: {
+        type?: GeometryType;
+        srid?: number;
+    });
+    /**
+     * Get the geometry type in uppercase
+     */
+    getGeometryType(): string | undefined;
+    toSqlString(dialect?: string): string;
+}
+/**
+ * Geography - for geographic/spatial data (uses WGS84 coordinate system)
+ * Unlike GEOMETRY, GEOGRAPHY performs calculations using spherical geography
+ *
+ * @example
+ * // Basic geography (defaults to WGS84 - SRID 4326)
+ * location: DataTypes.GEOGRAPHY
+ *
+ * // Geography with specific type
+ * point: DataTypes.GEOGRAPHY('POINT')
+ * area: DataTypes.GEOGRAPHY('POLYGON', 4326)
+ *
+ * // Geography with type and custom SRID
+ * // 4326 = WGS 84 (most common)
+ * // 3857 = Web Mercator
+ * region: DataTypes.GEOGRAPHY('MULTIPOLYGON', 4326)
+ */
+declare class GEOGRAPHY extends AbstractDataType {
+    key: "GEOGRAPHY";
+    /**
+     * The geography type (POINT, LINESTRING, POLYGON, etc.)
+     */
+    type?: GeometryType;
+    /**
+     * SRID (Spatial Reference System Identifier)
+     * Default is 4326 (WGS 84)
+     * Only 4326 (WGS84) is officially supported by PostGIS for geography
+     */
+    srid?: number;
+    constructor(type?: GeometryType, srid?: number);
+    constructor(options?: {
+        type?: GeometryType;
+        srid?: number;
+    });
+    /**
+     * Get the geography type in uppercase
+     */
+    getGeographyType(): string | undefined;
+    /**
+     * Get the SRID (defaults to 4326 for WGS84)
+     */
+    getSRID(): number;
+    toSqlString(dialect?: string): string;
+}
+/**
+ * POINT - specific geometry type for points
+ * Shorthand for GEOMETRY('POINT', srid)
+ *
+ * @example
+ * // Point with default SRID (4326)
+ * location: DataTypes.POINT()
+ *
+ * // Point with custom SRID
+ * location: DataTypes.POINT(4326)
+ */
+declare class POINT extends AbstractDataType {
+    key: "POINT";
+    /**
+     * SRID (Spatial Reference System Identifier)
+     * Default is 4326 (WGS 84)
+     */
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+/**
+ * LINESTRING - specific geometry type for lines
+ * Shorthand for GEOMETRY('LINESTRING', srid)
+ *
+ * @example
+ * // LineString with default SRID (4326)
+ * route: DataTypes.LINESTRING()
+ *
+ * // LineString with custom SRID
+ * route: DataTypes.LINESTRING(4326)
+ */
+declare class LINESTRING extends AbstractDataType {
+    key: "LINESTRING";
+    /**
+     * SRID (Spatial Reference System Identifier)
+     * Default is 4326 (WGS 84)
+     */
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+/**
+ * POLYGON - specific geometry type for polygons
+ * Shorthand for GEOMETRY('POLYGON', srid)
+ *
+ * @example
+ * // Polygon with default SRID (4326)
+ * boundary: DataTypes.POLYGON()
+ *
+ * // Polygon with custom SRID
+ * boundary: DataTypes.POLYGON(4326)
+ */
+declare class POLYGON extends AbstractDataType {
+    key: "POLYGON";
+    /**
+     * SRID (Spatial Reference System Identifier)
+     * Default is 4326 (WGS 84)
+     */
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class MULTIPOINT extends AbstractDataType {
+    key: "MULTIPOINT";
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class MULTILINESTRING extends AbstractDataType {
+    key: "MULTILINESTRING";
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class MULTIPOLYGON extends AbstractDataType {
+    key: "MULTIPOLYGON";
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class GEOMETRYCOLLECTION extends AbstractDataType {
+    key: "GEOMETRYCOLLECTION";
+    srid?: number;
+    constructor(srid?: number);
+    toSqlString(dialect?: string): string;
+}
+declare class SET extends AbstractDataType {
+    key: "SET";
+    values: string[];
+    /**
+     * Create a SET data type
+     * @param values - Either an array of values or individual string values
+     * @example
+     * // Array of values
+     * DataTypes.SET(['red', 'green', 'blue'])
+     * // Individual values
+     * DataTypes.SET('red', 'green', 'blue')
+     */
+    constructor(...values: (string | string[])[]);
+    toSqlString(dialect?: string): string;
+    /**
+     * Get the values for validation
+     */
+    getValues(): string[];
+    /**
+     * Validate if a value is valid for this SET
+     */
+    validate(value: string): boolean;
+}
+declare class JSONColumn extends AbstractDataType {
+    key: "JSONCOLUMN";
+    validate?: boolean;
+    unescapedUnicode?: boolean;
+    compact?: boolean;
+    /**
+     * Create a JSON column type
+     * @param options - Options for JSON column
+     * @example
+     * // Basic JSON column
+     * DataTypes.JSONCOLUMN()
+     * // JSON column with validation
+     * DataTypes.JSONCOLUMN({ validate: true })
+     */
+    constructor(options?: {
+        validate?: boolean;
+        unescapedUnicode?: boolean;
+        compact?: boolean;
+    });
+    toSqlString(dialect?: string): string;
+}
+export interface VirtualFieldOptions {
+    /**
+     * The return type for the virtual field (used for type casting)
+     */
+    returnType?: AbstractDataType;
+    /**
+     * Getter function to compute the virtual field value
+     * Can access other fields via 'this'
+     */
+    get?: () => any;
+    /**
+     * Setter function to handle setting the virtual field
+     * Can update other fields when the virtual field is set
+     */
+    set?: (value: any) => void;
+    /**
+     * Array of field names that this virtual field depends on
+     * Used for tracking changes and reactivity
+     */
+    dependencies?: string[];
+}
+/**
+ * Options for VIRTUALSTRING - virtual string field with getter/setter support
+ */
+export interface VirtualStringOptions {
+    /**
+     * Getter function to compute the virtual string value
+     * Can access other fields via 'this'
+     */
+    get?: () => string;
+    /**
+     * Setter function to handle setting the virtual string
+     * Can transform or update other fields when the virtual field is set
+     */
+    set?: (value: string) => void;
+    /**
+     * Maximum length for validation (optional)
+     */
+    length?: number;
+    /**
+     * Array of field names that this virtual field depends on
+     * Used for tracking changes and reactivity
+     */
+    dependencies?: string[];
+}
+declare class VIRTUAL extends AbstractDataType {
+    key: "VIRTUAL";
+    returnType?: AbstractDataType;
+    /**
+     * Getter function to compute the virtual field value
+     */
+    get?: () => any;
+    /**
+     * Setter function to handle setting the virtual field
+     */
+    set?: (value: any) => void;
+    /**
+     * Array of field names that this virtual field depends on
+     */
+    dependencies?: string[];
+    constructor(options?: VirtualFieldOptions);
+    toSqlString(): string;
+    /**
+     * Check if this virtual field has a getter
+     */
+    hasGetter(): boolean;
+    /**
+     * Check if this virtual field has a setter
+     */
+    hasSetter(): boolean;
+    /**
+     * Get the dependencies for this virtual field
+     */
+    getDependencies(): string[];
+}
+/**
+ * VIRTUALSTRING - virtual string field with getter/setter support
+ * Does not create a database column but provides computed string values
+ *
+ * @example
+ * // Virtual string with getter (computed from other fields)
+ * fullName: DataTypes.VIRTUALSTRING({
+ *   get() {
+ *     return `${this.firstName} ${this.lastName}`;
+ *   },
+ *   dependencies: ['firstName', 'lastName']
+ * })
+ *
+ * // Virtual string with getter and setter
+ * email: DataTypes.VIRTUALSTRING({
+ *   get() {
+ *     return this._email?.toLowerCase();
+ *   },
+ *   set(value: string) {
+ *     this._email = value.trim().toLowerCase();
+ *   },
+ *   length: 255
+ * })
+ */
+declare class VIRTUALSTRING extends AbstractDataType {
+    key: "VIRTUALSTRING";
+    /**
+     * Getter function to compute the virtual string value
+     */
+    get?: () => string;
+    /**
+     * Setter function to handle setting the virtual string
+     */
+    set?: (value: string) => void;
+    /**
+     * Maximum length for validation (optional)
+     */
+    length?: number;
+    /**
+     * Array of field names that this virtual field depends on
+     */
+    dependencies?: string[];
+    constructor(options?: VirtualStringOptions);
+    toSqlString(): string;
+    /**
+     * Check if this virtual string field has a getter
+     */
+    hasGetter(): boolean;
+    /**
+     * Check if this virtual string field has a setter
+     */
+    hasSetter(): boolean;
+    /**
+     * Get the dependencies for this virtual field
+     */
+    getDependencies(): string[];
+    /**
+     * Get the maximum length for validation
+     */
+    getLength(): number | undefined;
+}
+/**
+ * VIRTUALSTRING - virtual string field that doesn't exist in the database
+ * Provides getter/setter support for computed string values
+ *
+ * @example
+ * // Virtual string with getter
+ * fullName: DataTypes.VIRTUALSTRING({
+ *   get: function() {
+ *     return this.firstName + ' ' + this.lastName;
+ *   },
+ *   dependencies: ['firstName', 'lastName']
+ * })
+ *
+ * // Virtual string with getter and setter
+ * displayName: DataTypes.VIRTUALSTRING({
+ */
+export type HashAlgorithm = 'BCRYPT' | 'MD5' | 'SHA1' | 'SHA256' | 'SHA384' | 'SHA512' | 'SHA512_256' | 'ARGON2' | 'PBKDF2' | 'SCRYPT' | 'NTLM' | 'MYSQL' | 'POSTGRESQL_MD5';
+/**
+ * Options for ALGORITHM data type
+ */
+export interface AlgorithmOptions {
+    /**
+     * The hash algorithm to use
+     * Supported algorithms:
+     * - BCRYPT: Blowfish-based bcrypt (default cost 10)
+     * - MD5: Message Digest 5 (128-bit hash, 32 hex chars)
+     * - SHA1: Secure Hash Algorithm 1 (160-bit hash, 40 hex chars)
+     * - SHA256: SHA-2 256-bit (64 hex chars)
+     * - SHA384: SHA-2 384-bit (96 hex chars)
+     * - SHA512: SHA-2 512-bit (128 hex chars)
+     * - SHA512_256: SHA-2 512/256-bit (64 hex chars)
+     * - ARGON2: Argon2 password hashing (winner of PHC)
+     * - PBKDF2: Password-Based Key Derivation Function 2
+     * - SCRYPT: Memory-hard hash function
+     * - NTLM: Windows NT LAN Manager hash
+     * - MYSQL: MySQL password hash
+     * - POSTGRESQL_MD5: PostgreSQL MD5 hash
+     */
+    algorithm: HashAlgorithm;
+    /**
+     * Cost factor for the algorithm (for BCRYPT, ARGON2, PBKDF2, SCRYPT)
+     * - BCRYPT: Number of rounds (default 10, range 4-31)
+     * - ARGON2: Memory cost in KB (default 65536)
+     * - PBKDF2: Number of iterations (default 100000)
+     * - SCRYPT: Memory/cost parameter (default 16384)
+     */
+    cost?: number;
+    /**
+     * Salt length in bytes (for algorithms that support it)
+     */
+    saltLength?: number;
+    /**
+     * Hash length in bytes (for algorithms that support it)
+     */
+    hashLength?: number;
+    /**
+     * Whether to include the salt in the output (for BCRYPT, ARGON2)
+     * Default: true (includes salt in hash string)
+     */
+    includeSalt?: boolean;
+    /**
+     * Parallelism parameter (for ARGON2)
+     * Default: 1
+     */
+    parallelism?: number;
+    /**
+     * Block size parameter (for ARGON2)
+     * Default: 8
+     */
+    blockSize?: number;
+}
+/**
+ * ALGORITHM - data type for hash algorithms
+ * Used for storing hashed values (passwords, checksums, etc.)
+ * Can be used with VIRTUAL type for computed/hashed fields
+ *
+ * Common output lengths:
+ * - MD5: 32 hex chars (16 bytes)
+ * - SHA1: 40 hex chars (20 bytes)
+ * - SHA256: 64 hex chars (32 bytes)
+ * - SHA384: 96 hex chars (48 bytes)
+ * - SHA512: 128 hex chars (64 bytes)
+ * - BCRYPT: 60 chars (with $2a$ or $2b$ prefix)
+ * - ARGON2: Variable, typically ~100 chars (with $argon2$ prefix)
+ * - PBKDF2: Variable based on hash length
+ *
+ * @example
+ * // Store password hash using BCRYPT (recommended for passwords)
+ * password: DataTypes.ALGORITHM({ algorithm: 'BCRYPT', cost: 12 })
+ *
+ * // Store checksum using SHA256
+ * fileChecksum: DataTypes.ALGORITHM({ algorithm: 'SHA256' })
+ *
+ * // Store password hash using ARGON2
+ * password: DataTypes.ALGORITHM({ algorithm: 'ARGON2', cost: 65536, parallelism: 2 })
+ *
+ * // Use with VIRTUAL for auto-hashing on set
+ * passwordHash: DataTypes.VIRTUAL({
+ *   returnType: DataTypes.ALGORITHM({ algorithm: 'BCRYPT' }),
+ *   set(value: string) {
+ *     this.password = hashPassword(value);
+ *   }
+ * })
+ */
+declare class ALGORITHM extends AbstractDataType {
+    key: "ALGORITHM";
+    /**
+     * The hash algorithm to use
+     */
+    algorithm: HashAlgorithm;
+    /**
+     * Cost factor/rounds for the algorithm
+     */
+    cost?: number;
+    /**
+     * Salt length in bytes
+     */
+    saltLength?: number;
+    /**
+     * Hash length in bytes
+     */
+    hashLength?: number;
+    /**
+     * Whether to include salt in output
+     */
+    includeSalt?: boolean;
+    /**
+     * Parallelism parameter (for ARGON2)
+     */
+    parallelism?: number;
+    /**
+     * Block size parameter (for ARGON2)
+     */
+    blockSize?: number;
+    /**
+     * Get the default cost/rounds for each algorithm
+     */
+    private getDefaultCost;
+    /**
+     * Get the output length for each algorithm (in characters for VARCHAR)
+     * This accounts for the full hash including prefixes, salts, etc.
+     */
+    private getOutputLength;
+    constructor(options: AlgorithmOptions);
+    /**
+     * Get the algorithm name
+     */
+    getAlgorithm(): HashAlgorithm;
+    /**
+     * Check if this is a password hashing algorithm (slow hash)
+     * Password hashing algorithms are designed to be slow to prevent brute force
+     */
+    isPasswordHash(): boolean;
+    /**
+     * Check if this is a fast hash algorithm (checksums)
+     */
+    isFastHash(): boolean;
+    /**
+     * Get the configuration object for hashing libraries
+     */
+    getHashConfig(): object;
+    toSqlString(dialect?: string): string;
+}
+export declare const DataTypes: {
+    STRING: ((...args: any[]) => STRING) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    VARCHAR: ((...args: any[]) => VARCHAR) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    CHAR: ((...args: any[]) => CHAR) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TEXT: ((...args: any[]) => TEXT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TINYTEXT: ((...args: any[]) => TINYTEXT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MEDIUMTEXT: ((...args: any[]) => MEDIUMTEXT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    LONGTEXT: ((...args: any[]) => LONGTEXT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    INTEGER: ((...args: any[]) => INTEGER) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TINYINT: ((...args: any[]) => TINYINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    SMALLINT: ((...args: any[]) => SMALLINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MEDIUMINT: ((...args: any[]) => MEDIUMINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    BIGINT: ((...args: any[]) => BIGINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    FLOAT: ((...args: any[]) => FLOAT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    DOUBLE: ((...args: any[]) => DOUBLE) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    DECIMAL: ((...args: any[]) => DECIMAL) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    REAL: ((...args: any[]) => REAL) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    BOOLEAN: ((...args: any[]) => BOOLEAN) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    DATE: ((...args: any[]) => DATE) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    DATEONLY: ((...args: any[]) => DATEONLY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    DATETIME: ((...args: any[]) => DATETIME) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TIMESTAMP: ((...args: any[]) => TIMESTAMP) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    NOW: ((...args: any[]) => NOW) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TIME: ((...args: any[]) => TIME) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    UUID: ((...args: any[]) => UUID) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    UUIDV1: ((...args: any[]) => UUIDV1) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    UUIDV4: ((...args: any[]) => UUIDV4) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    JSON: ((...args: any[]) => JSON) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    JSONB: ((...args: any[]) => JSONB) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    HSTORE: ((...args: any[]) => HSTORE) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    RANGE: ((...args: any[]) => RANGE) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    INET: ((...args: any[]) => INET) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    INET6: ((...args: any[]) => INET) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    CIDR: ((...args: any[]) => CIDR) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MACADDR: ((...args: any[]) => MACADDR) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    BLOB: ((...args: any[]) => BLOB) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    TINYBLOB: ((...args: any[]) => TINYBLOB) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MEDIUMBLOB: ((...args: any[]) => MEDIUMBLOB) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    LONGBLOB: ((...args: any[]) => LONGBLOB) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    BINARY: ((...args: any[]) => BINARY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    VARBINARY: ((...args: any[]) => VARBINARY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * ENUM data type
+     * @param values - Either an array of values or individual string values
+     * @example
+     * // Array of values
+     * status: { type: DataTypes.ENUM(['active', 'inactive', 'pending']) }
+     * // Individual values
+     * role: DataTypes.ENUM('admin', 'user', 'guest')
+     */
+    ENUM: ((...args: any[]) => ENUM) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    ARRAY: ((...args: any[]) => ARRAY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * LIST data type - DuckDB native variable-length list (`elementType[]`)
+     * @param type - The data type of list elements
+     * @example
+     * tags: DataTypes.LIST(DataTypes.INTEGER)
+     */
+    LIST: ((...args: any[]) => LIST) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * STRUCT data type - DuckDB native nested record (`STRUCT(field TYPE, ...)`)
+     * @param fields - A map of field name -> field data type
+     * @example
+     * point: DataTypes.STRUCT({ x: DataTypes.INTEGER, y: DataTypes.INTEGER })
+     */
+    STRUCT: ((...args: any[]) => STRUCT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * MAP data type - DuckDB native key/value map (`MAP(keyType, valueType)`)
+     * @param keyType - The data type of map keys
+     * @param valueType - The data type of map values
+     * @example
+     * scores: DataTypes.MAP(DataTypes.STRING, DataTypes.INTEGER)
+     */
+    MAP: ((...args: any[]) => MAP) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * UNION data type - DuckDB native tagged union (`UNION(tag TYPE, ...)`)
+     * @param fields - A map of tag name -> alternative data type
+     * @example
+     * value: DataTypes.UNION({ num: DataTypes.INTEGER, str: DataTypes.STRING })
+     */
+    UNION: ((...args: any[]) => DUCKDB_UNION) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    GEOMETRY: ((...args: any[]) => GEOMETRY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    GEOGRAPHY: ((...args: any[]) => GEOGRAPHY) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    POINT: ((...args: any[]) => POINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    LINESTRING: ((...args: any[]) => LINESTRING) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    POLYGON: ((...args: any[]) => POLYGON) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MULTIPOINT: ((...args: any[]) => MULTIPOINT) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MULTILINESTRING: ((...args: any[]) => MULTILINESTRING) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    MULTIPOLYGON: ((...args: any[]) => MULTIPOLYGON) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    GEOMETRYCOLLECTION: ((...args: any[]) => GEOMETRYCOLLECTION) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    SET: ((...args: any[]) => SET) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    JSONCOLUMN: ((...args: any[]) => JSONColumn) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    VIRTUAL: ((...args: any[]) => VIRTUAL) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    VIRTUALSTRING: ((...args: any[]) => VIRTUALSTRING) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+    /**
+     * ALGORITHM data type for hash algorithms
+     * Used for storing hashed values (passwords, checksums, etc.)
+     * Supports BCRYPT, MD5, SHA1, SHA256, SHA384, SHA512, ARGON2, PBKDF2, SCRYPT, etc.
+     *
+     * @example
+     * // Store password hash using BCRYPT (recommended for passwords)
+     * password: DataTypes.ALGORITHM({ algorithm: 'BCRYPT', cost: 12 })
+     *
+     * // Store checksum using SHA256
+     * fileChecksum: DataTypes.ALGORITHM({ algorithm: 'SHA256' })
+     *
+     * // Use with VIRTUAL for computed hash fields
+     * passwordHash: DataTypes.VIRTUAL({
+     *   returnType: DataTypes.ALGORITHM({ algorithm: 'BCRYPT' }),
+     *   set(value: string) {
+     *     this.password = hashPassword(value);
+     *   }
+     * })
+     */
+    ALGORITHM: ((...args: any[]) => ALGORITHM) & {
+        toSql: () => string;
+        equals: (other: any) => boolean;
+        serialize: (value: unknown) => unknown;
+        key: string;
+    };
+};
+export { STRING, VARCHAR, CHAR, TEXT, TINYTEXT, MEDIUMTEXT, LONGTEXT, INTEGER, TINYINT, SMALLINT, MEDIUMINT, BIGINT, FLOAT, DOUBLE, DECIMAL, REAL, BOOLEAN, DATE, DATEONLY, DATETIME, TIMESTAMP, NOW, TIME, UUID, UUIDV1, UUIDV4, JSON, JSONB, BLOB, TINYBLOB, MEDIUMBLOB, LONGBLOB, BINARY, VARBINARY, ENUM, ARRAY, LIST, STRUCT, MAP, DUCKDB_UNION, GEOMETRY, GEOGRAPHY, POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION, SET, JSONColumn, VIRTUAL, VIRTUALSTRING, ALGORITHM, HSTORE, RANGE, INET, CIDR, MACADDR, AbstractDataType, };
+export type { DataType };