ts-prorm-orm 1.1.0

package/dist/models/data-types.js

@@ -0,0 +1,2518 @@
+"use strict";
+/**
+ * Data Types for the ORM
+ * Provides all standard data types with proper class implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRYCOLLECTION = exports.MULTIPOLYGON = exports.MULTILINESTRING = exports.MULTIPOINT = exports.POLYGON = exports.LINESTRING = exports.POINT = exports.GEOGRAPHY = exports.GEOMETRY = exports.DUCKDB_UNION = exports.MAP = exports.STRUCT = exports.LIST = exports.ARRAY = exports.ENUM = exports.VARBINARY = exports.BINARY = exports.LONGBLOB = exports.MEDIUMBLOB = exports.TINYBLOB = exports.BLOB = exports.JSONB = exports.JSON = exports.UUIDV4 = exports.UUIDV1 = exports.UUID = exports.TIME = exports.NOW = exports.TIMESTAMP = exports.DATETIME = exports.DATEONLY = exports.DATE = exports.BOOLEAN = exports.REAL = exports.DECIMAL = exports.DOUBLE = exports.FLOAT = exports.BIGINT = exports.MEDIUMINT = exports.SMALLINT = exports.TINYINT = exports.INTEGER = exports.LONGTEXT = exports.MEDIUMTEXT = exports.TINYTEXT = exports.TEXT = exports.CHAR = exports.VARCHAR = exports.STRING = exports.DataTypes = void 0;
+exports.AbstractDataType = exports.MACADDR = exports.CIDR = exports.INET = exports.RANGE = exports.HSTORE = exports.ALGORITHM = exports.VIRTUALSTRING = exports.VIRTUAL = exports.JSONColumn = exports.SET = void 0;
+/**
+ * Base class for all data types
+ */
+class AbstractDataType {
+    toSqlString(dialect) {
+        return this.key;
+    }
+    toSQL() {
+        return this.toSqlString();
+    }
+    // Alias for toSQL for compatibility
+    toSql() {
+        return this.toSqlString();
+    }
+    /**
+     * 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) {
+        if (!other || typeof other !== 'object') {
+            return false;
+        }
+        return this.key === other.key;
+    }
+    /**
+     * Serialize a value for storage based on this DataType
+     * @param value - The value to serialize
+     * @returns The serialized value
+     */
+    serialize(value) {
+        return value;
+    }
+}
+exports.AbstractDataType = AbstractDataType;
+// STRING types
+class STRING extends AbstractDataType {
+    /**
+     * 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, binary = false) {
+        super();
+        this.key = 'STRING';
+        this.length = length;
+        this.binary = binary;
+    }
+    toSqlString() {
+        // If no length specified, return TEXT
+        if (this.length === undefined || this.length === null) {
+            return 'TEXT';
+        }
+        const binaryStr = this.binary ? ' BINARY' : '';
+        return `VARCHAR(${this.length})${binaryStr}`;
+    }
+}
+exports.STRING = STRING;
+class VARCHAR extends AbstractDataType {
+    constructor(length = 255, binary = false) {
+        super();
+        this.key = 'VARCHAR';
+        this.length = length;
+        this.binary = binary;
+    }
+    toSqlString() {
+        const binaryStr = this.binary ? ' BINARY' : '';
+        return `VARCHAR(${this.length})${binaryStr}`;
+    }
+}
+exports.VARCHAR = VARCHAR;
+class CHAR extends AbstractDataType {
+    constructor(length = 1) {
+        super();
+        this.key = 'CHAR';
+        this.length = length;
+    }
+    toSqlString() {
+        return `CHAR(${this.length})`;
+    }
+}
+exports.CHAR = CHAR;
+// TEXT types
+class TEXT extends AbstractDataType {
+    constructor(length) {
+        super();
+        this.key = 'TEXT';
+        this.length = length;
+    }
+    /**
+     * Get the TEXT type string based on length variant for MySQL/MariaDB
+     */
+    getTextType() {
+        if (!this.length) {
+            return 'TEXT';
+        }
+        // MySQL/MariaDB format: TINYTEXT, MEDIUMTEXT, LONGTEXT
+        if (this.length === 'tiny')
+            return 'TINYTEXT';
+        if (this.length === 'medium')
+            return 'MEDIUMTEXT';
+        if (this.length === 'long')
+            return 'LONGTEXT';
+        return 'TEXT';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL: Use TEXT for all variants
+                return 'TEXT';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT
+                return this.getTextType();
+            case 'sqlite':
+                // SQLite: Use TEXT for all variants
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server: Use TEXT (deprecated) or NVARCHAR(MAX) for large text
+                return 'NVARCHAR(MAX)';
+            default:
+                // Default to standard TEXT
+                return this.getTextType();
+        }
+    }
+}
+exports.TEXT = TEXT;
+// Convenience classes for specific TEXT length variants (MySQL/MariaDB)
+class TINYTEXT extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'TINYTEXT';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+            case 'sqlite':
+                return 'TEXT';
+            case 'mysql':
+            case 'mariadb':
+                return 'TINYTEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return 'NVARCHAR(MAX)';
+            default:
+                return 'TINYTEXT';
+        }
+    }
+}
+exports.TINYTEXT = TINYTEXT;
+class MEDIUMTEXT extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'MEDIUMTEXT';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+            case 'sqlite':
+                return 'TEXT';
+            case 'mysql':
+            case 'mariadb':
+                return 'MEDIUMTEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return 'NVARCHAR(MAX)';
+            default:
+                return 'MEDIUMTEXT';
+        }
+    }
+}
+exports.MEDIUMTEXT = MEDIUMTEXT;
+class LONGTEXT extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'LONGTEXT';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+            case 'sqlite':
+                return 'TEXT';
+            case 'mysql':
+            case 'mariadb':
+                return 'LONGTEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return 'NVARCHAR(MAX)';
+            default:
+                return 'LONGTEXT';
+        }
+    }
+}
+exports.LONGTEXT = LONGTEXT;
+// Base class for integer types with unsigned and zerofill support
+class AbstractIntegerType extends AbstractDataType {
+    /**
+     * Set as unsigned
+     * @example
+     * DataTypes.INTEGER.UNSIGNED()
+     * DataTypes.BIGINT.UNSIGNED()
+     */
+    UNSIGNED() {
+        this.unsigned = true;
+        return this;
+    }
+    /**
+     * Set as zerofill
+     * @example
+     * DataTypes.INTEGER.ZEROFILL()
+     * DataTypes.INTEGER.UNSIGNED().ZEROFILL()
+     */
+    ZEROFILL() {
+        this.zerofill = true;
+        return this;
+    }
+    /**
+     * Generate SQL string with unsigned and zerofill options
+     */
+    toSqlStringHelper(baseType) {
+        let sql = baseType;
+        if (this.length) {
+            sql = `${baseType}(${this.length})`;
+        }
+        if (this.unsigned) {
+            sql += ' UNSIGNED';
+        }
+        if (this.zerofill) {
+            sql += ' ZEROFILL';
+        }
+        return sql;
+    }
+}
+// Number types
+class INTEGER extends AbstractIntegerType {
+    constructor(options = {}) {
+        super();
+        this.key = 'INTEGER';
+        this.length = options.length;
+        this.unsigned = options.unsigned;
+        this.zerofill = options.zerofill;
+    }
+    toSqlString() {
+        return this.toSqlStringHelper('INTEGER');
+    }
+}
+exports.INTEGER = INTEGER;
+// TINYINT - tiny integer (1 byte, -128 to 127 signed, 0 to 255 unsigned)
+class TINYINT extends AbstractIntegerType {
+    /**
+     * 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 = {}) {
+        super();
+        this.key = 'TINYINT';
+        this.length = options.length;
+        this.unsigned = options.unsigned;
+        this.zerofill = options.zerofill;
+    }
+    toSqlString() {
+        return this.toSqlStringHelper('TINYINT');
+    }
+}
+exports.TINYINT = TINYINT;
+// SMALLINT - small integer (2 bytes, -32768 to 32767 signed, 0 to 65535 unsigned)
+class SMALLINT extends AbstractIntegerType {
+    /**
+     * 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 = {}) {
+        super();
+        this.key = 'SMALLINT';
+        this.length = options.length;
+        this.unsigned = options.unsigned;
+        this.zerofill = options.zerofill;
+    }
+    toSqlString() {
+        return this.toSqlStringHelper('SMALLINT');
+    }
+}
+exports.SMALLINT = SMALLINT;
+// MEDIUMINT - medium integer (3 bytes, -8388608 to 8388607 signed, 0 to 16777215 unsigned)
+class MEDIUMINT extends AbstractIntegerType {
+    /**
+     * 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 = {}) {
+        super();
+        this.key = 'MEDIUMINT';
+        this.length = options.length;
+        this.unsigned = options.unsigned;
+        this.zerofill = options.zerofill;
+    }
+    toSqlString() {
+        return this.toSqlStringHelper('MEDIUMINT');
+    }
+}
+exports.MEDIUMINT = MEDIUMINT;
+class BIGINT extends AbstractIntegerType {
+    /**
+     * 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 = {}) {
+        super();
+        this.key = 'BIGINT';
+        this.length = options.length;
+        this.unsigned = options.unsigned;
+        this.zerofill = options.zerofill;
+    }
+    toSqlString() {
+        return this.toSqlStringHelper('BIGINT');
+    }
+}
+exports.BIGINT = BIGINT;
+class FLOAT extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'FLOAT';
+        if (typeof precisionOrOptions === 'number') {
+            this.precision = precisionOrOptions;
+        }
+        else if (precisionOrOptions) {
+            this.precision = precisionOrOptions.precision;
+            this.decimals = precisionOrOptions.decimals;
+            this.unsigned = precisionOrOptions.unsigned;
+        }
+    }
+    toSqlString(dialect) {
+        let sql = 'FLOAT';
+        if (this.precision) {
+            // MySQL/MariaDB support FLOAT(p) where p is precision
+            if (this.decimals) {
+                sql = `FLOAT(${this.precision},${this.decimals})`;
+            }
+            else if (dialect === 'mysql' || dialect === 'mariadb') {
+                sql = `FLOAT(${this.precision})`;
+            }
+        }
+        if (this.unsigned) {
+            sql += ' UNSIGNED';
+        }
+        return sql;
+    }
+}
+exports.FLOAT = FLOAT;
+class DOUBLE extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'DOUBLE';
+        if (typeof precisionOrOptions === 'number') {
+            this.precision = precisionOrOptions;
+        }
+        else if (precisionOrOptions) {
+            this.precision = precisionOrOptions.precision;
+            this.decimals = precisionOrOptions.decimals;
+            this.unsigned = precisionOrOptions.unsigned;
+        }
+    }
+    toSqlString(dialect) {
+        let sql = 'DOUBLE';
+        if (this.precision) {
+            // MySQL/MariaDB support DOUBLE(p) where p is precision
+            if (this.decimals) {
+                sql = `DOUBLE(${this.precision},${this.decimals})`;
+            }
+            else if (dialect === 'mysql' || dialect === 'mariadb') {
+                sql = `DOUBLE(${this.precision})`;
+            }
+        }
+        else if (this.decimals) {
+            // Backward compatibility: DOUBLE with only decimals
+            sql = `DOUBLE(10,${this.decimals})`;
+        }
+        if (this.unsigned) {
+            sql += ' UNSIGNED';
+        }
+        return sql;
+    }
+}
+exports.DOUBLE = DOUBLE;
+class DECIMAL extends AbstractDataType {
+    /**
+     * 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, scale = 0, unsigned = false) {
+        super();
+        this.key = 'DECIMAL';
+        if (typeof precisionOrOptions === 'number') {
+            this.precision = precisionOrOptions;
+            this.scale = scale;
+            this.unsigned = unsigned;
+        }
+        else if (precisionOrOptions) {
+            this.precision = precisionOrOptions.precision ?? 10;
+            this.scale = precisionOrOptions.scale ?? 0;
+            this.unsigned = precisionOrOptions.unsigned;
+        }
+        else {
+            // Default: DECIMAL(10, 0)
+            this.precision = 10;
+            this.scale = 0;
+            this.unsigned = false;
+        }
+    }
+    toSqlString(dialect) {
+        let sql = `DECIMAL(${this.precision},${this.scale})`;
+        // UNSIGNED is not standard for DECIMAL in most dialects
+        // Only MySQL/MariaDB support it
+        if (this.unsigned && (dialect === 'mysql' || dialect === 'mariadb')) {
+            sql += ' UNSIGNED';
+        }
+        return sql;
+    }
+}
+exports.DECIMAL = DECIMAL;
+// Boolean
+class BOOLEAN extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'BOOLEAN';
+    }
+    toSqlString() {
+        return 'INTEGER'; // SQLite uses INTEGER for booleans
+    }
+}
+exports.BOOLEAN = BOOLEAN;
+// Date types
+class DATE extends AbstractDataType {
+    constructor(precision, timezone = false) {
+        super();
+        this.key = 'DATE';
+        this.precision = precision;
+        this.timezone = timezone;
+    }
+    toSqlString(dialect) {
+        const precisionStr = this.precision !== undefined ? `(${this.precision})` : '';
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL: TIMESTAMP WITH/WITHOUT TIME ZONE
+                return this.timezone
+                    ? `TIMESTAMP${precisionStr} WITH TIME ZONE`
+                    : `TIMESTAMP${precisionStr}`;
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: DATETIME or TIMESTAMP
+                return `DATETIME${precisionStr}`;
+            case 'sqlite':
+                // SQLite stores dates as TEXT in ISO8601 format
+                return `TEXT`;
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server: DATETIME2 for more precision
+                return `DATETIME2${precisionStr}`;
+            default:
+                return `DATETIME${precisionStr}`;
+        }
+    }
+}
+exports.DATE = DATE;
+class DATEONLY extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'DATEONLY';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL: DATE
+                return 'DATE';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: DATE
+                return 'DATE';
+            case 'sqlite':
+                // SQLite stores dates as TEXT in ISO8601 format (YYYY-MM-DD)
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server: DATE
+                return 'DATE';
+            default:
+                return 'DATE';
+        }
+    }
+}
+exports.DATEONLY = DATEONLY;
+class TIME extends AbstractDataType {
+    constructor(precision, timezone = false) {
+        super();
+        this.key = 'TIME';
+        this.precision = precision;
+        this.timezone = timezone;
+    }
+    toSqlString(dialect) {
+        const precisionStr = this.precision !== undefined ? `(${this.precision})` : '';
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL: TIME WITH/WITHOUT TIME ZONE
+                return this.timezone ? `TIME${precisionStr} WITH TIME ZONE` : `TIME${precisionStr}`;
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: TIME
+                return `TIME${precisionStr}`;
+            case 'sqlite':
+                // SQLite stores time as TEXT in ISO8601 format
+                return `TEXT`;
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server: TIME
+                return `TIME${precisionStr}`;
+            default:
+                return `TIME${precisionStr}`;
+        }
+    }
+}
+exports.TIME = TIME;
+// REAL - single-precision floating point (native SQLite storage class,
+// PostgreSQL/MSSQL 4-byte float, alias for FLOAT/DOUBLE in MySQL/MariaDB)
+class REAL extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'REAL';
+        if (typeof precisionOrOptions === 'number') {
+            this.precision = precisionOrOptions;
+        }
+        else if (precisionOrOptions) {
+            this.precision = precisionOrOptions.precision;
+            this.decimals = precisionOrOptions.decimals;
+            this.unsigned = precisionOrOptions.unsigned;
+        }
+    }
+    toSqlString(dialect) {
+        let sql = 'REAL';
+        if (this.precision && this.decimals && (dialect === 'mysql' || dialect === 'mariadb')) {
+            // MySQL/MariaDB REAL is an alias for DOUBLE and supports (precision,decimals)
+            sql = `REAL(${this.precision},${this.decimals})`;
+        }
+        if (this.unsigned && (dialect === 'mysql' || dialect === 'mariadb')) {
+            sql += ' UNSIGNED';
+        }
+        return sql;
+    }
+}
+exports.REAL = REAL;
+// TIMESTAMP - dedicated timestamp type distinct from DATE/NOW
+class TIMESTAMP extends AbstractDataType {
+    constructor(precision) {
+        super();
+        this.key = 'TIMESTAMP';
+        this.precision = precision;
+    }
+    toSqlString(dialect) {
+        const precisionStr = this.precision !== undefined ? `(${this.precision})` : '';
+        switch (dialect) {
+            case 'postgres':
+                return `TIMESTAMP${precisionStr}`;
+            case 'mysql':
+            case 'mariadb':
+                return `TIMESTAMP${precisionStr}`;
+            case 'sqlite':
+                // SQLite stores timestamps as TEXT in ISO8601 format
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return `DATETIME2${precisionStr}`;
+            default:
+                return `TIMESTAMP${precisionStr}`;
+        }
+    }
+    /**
+     * Get the current timestamp SQL for use as a default value
+     */
+    toDefaultValue(dialect) {
+        switch (dialect) {
+            case 'sqlite':
+                return "datetime('now')";
+            case 'mssql':
+            case 'sqlserver':
+                return 'GETDATE()';
+            default:
+                return 'CURRENT_TIMESTAMP';
+        }
+    }
+}
+exports.TIMESTAMP = TIMESTAMP;
+// DATETIME - explicit datetime type (distinct from DATE, which supports timezone options)
+class DATETIME extends AbstractDataType {
+    constructor(precision) {
+        super();
+        this.key = 'DATETIME';
+        this.precision = precision;
+    }
+    toSqlString(dialect) {
+        const precisionStr = this.precision !== undefined ? `(${this.precision})` : '';
+        switch (dialect) {
+            case 'postgres':
+                return `TIMESTAMP${precisionStr}`;
+            case 'mysql':
+            case 'mariadb':
+                return `DATETIME${precisionStr}`;
+            case 'sqlite':
+                // SQLite stores dates as TEXT in ISO8601 format
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return `DATETIME2${precisionStr}`;
+            default:
+                return `DATETIME${precisionStr}`;
+        }
+    }
+}
+exports.DATETIME = DATETIME;
+// UUID - stores UUID strings (works with all dialects)
+class UUID extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'UUID';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'UUID';
+            case 'mysql':
+            case 'mariadb':
+                return 'VARCHAR(36)';
+            case 'sqlite':
+            default:
+                return 'TEXT';
+        }
+    }
+}
+exports.UUID = UUID;
+// UUIDV4 - auto-generates UUID v4 on insert (works with all dialects)
+class UUIDV4 extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'UUIDV4';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'UUID';
+            case 'mysql':
+            case 'mariadb':
+                return 'VARCHAR(36)';
+            case 'sqlite':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * 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) {
+        return UUIDV4.generate();
+    }
+    /**
+     * Generate a UUID v4 string (instance method)
+     */
+    generate() {
+        return UUIDV4.generate();
+    }
+    /**
+     * Generate a UUID v4 string (static method)
+     */
+    static generate() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+}
+exports.UUIDV4 = UUIDV4;
+// UUIDV1 - auto-generates a time-based UUID v1 on insert (works with all dialects)
+class UUIDV1 extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'UUIDV1';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'UUID';
+            case 'mysql':
+            case 'mariadb':
+                return 'VARCHAR(36)';
+            case 'sqlite':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * 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) {
+        return UUIDV1.generate();
+    }
+    /**
+     * Generate a UUID v1 string (instance method)
+     */
+    generate() {
+        return UUIDV1.generate();
+    }
+    /**
+     * 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() {
+        // 100-nanosecond intervals between the UUID epoch (1582-10-15) and the Unix epoch
+        const UUID_EPOCH_OFFSET = 122192928000000000n;
+        const timestamp = BigInt(Date.now()) * 10000n + UUID_EPOCH_OFFSET;
+        const timeLow = (timestamp & 0xffffffffn).toString(16).padStart(8, '0');
+        const timeMid = ((timestamp >> 32n) & 0xffffn).toString(16).padStart(4, '0');
+        const timeHiAndVersion = (((timestamp >> 48n) & 0x0fffn) | 0x1000n)
+            .toString(16)
+            .padStart(4, '0');
+        const clockSeq = ((Math.floor(Math.random() * 0x3fff) & 0x3fff) | 0x8000)
+            .toString(16)
+            .padStart(4, '0');
+        const node = Array.from({ length: 6 }, () => Math.floor(Math.random() * 256)
+            .toString(16)
+            .padStart(2, '0')).join('');
+        return `${timeLow}-${timeMid}-${timeHiAndVersion}-${clockSeq}-${node}`;
+    }
+}
+exports.UUIDV1 = UUIDV1;
+// NOW - current timestamp
+class NOW extends AbstractDataType {
+    constructor(precision) {
+        super();
+        this.key = 'NOW';
+        this.precision = precision;
+    }
+    /**
+     * 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) {
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL: CURRENT_TIMESTAMP or NOW()
+                return 'CURRENT_TIMESTAMP';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: CURRENT_TIMESTAMP or NOW()
+                return 'CURRENT_TIMESTAMP';
+            case 'sqlite':
+                // SQLite: datetime('now')
+                return "datetime('now')";
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server: GETDATE() or GETUTCDATE()
+                return 'GETDATE()';
+            default:
+                // Default to standard SQL
+                return 'CURRENT_TIMESTAMP';
+        }
+    }
+    toSqlString(dialect) {
+        // When used as a column type, generate proper DATETIME type
+        const precisionStr = this.precision !== undefined ? `(${this.precision})` : '';
+        switch (dialect) {
+            case 'postgres':
+                return `TIMESTAMP${precisionStr}`;
+            case 'mysql':
+            case 'mariadb':
+                return `DATETIME${precisionStr}`;
+            case 'sqlite':
+                // SQLite uses TEXT for timestamps but supports datetime() function
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                return `DATETIME2${precisionStr}`;
+            default:
+                return 'DATETIME';
+        }
+    }
+}
+exports.NOW = NOW;
+// JSON types with dialect-specific handling
+/**
+ * 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()
+ */
+class JSON extends AbstractDataType {
+    constructor(useNative = false) {
+        super();
+        this.key = 'JSON';
+        this.useNative = useNative;
+    }
+    toSqlString(dialect) {
+        // If useNative is false, always use TEXT
+        if (!this.useNative) {
+            return 'TEXT';
+        }
+        switch (dialect) {
+            case 'postgres':
+            case 'mysql':
+            case 'mariadb':
+                return 'JSON';
+            case 'sqlite':
+            default:
+                return 'TEXT';
+        }
+    }
+}
+exports.JSON = JSON;
+/**
+ * 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)
+ */
+class JSONB extends AbstractDataType {
+    constructor(useNative = false) {
+        super();
+        this.key = 'JSONB';
+        this.useNative = useNative;
+    }
+    toSqlString(dialect) {
+        // If useNative is false, always use TEXT
+        if (!this.useNative) {
+            return 'TEXT';
+        }
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL has native JSONB support
+                return 'JSONB';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: No native JSONB, use JSON type (TEXT fallback)
+                return 'JSON';
+            case 'sqlite':
+            default:
+                // SQLite: No native JSON/JSONB support
+                return 'TEXT';
+        }
+    }
+}
+exports.JSONB = JSONB;
+// HSTORE - PostgreSQL key-value type
+// Requires: CREATE EXTENSION IF NOT EXISTS hstore
+class HSTORE extends AbstractDataType {
+    constructor(useNative = true) {
+        super();
+        this.key = 'HSTORE';
+        this.useNative = useNative;
+    }
+    toSqlString(dialect) {
+        if (!this.useNative) {
+            // Fallback to JSONB for dialects without HStore support
+            return 'JSONB';
+        }
+        switch (dialect) {
+            case 'postgres':
+                return 'HSTORE';
+            case 'mysql':
+            case 'mariadb':
+            case 'sqlite':
+            default:
+                // No native HStore support, fallback to JSONB
+                return 'JSONB';
+        }
+    }
+    /**
+     * Get the SQL to create the HStore extension (PostgreSQL)
+     */
+    static getExtensionSQL() {
+        return 'CREATE EXTENSION IF NOT EXISTS hstore';
+    }
+}
+exports.HSTORE = HSTORE;
+// RANGE - PostgreSQL range types
+// Range types: int4range, int8range, numrange, tsrange, tstzrange, daterange
+class RANGE extends AbstractDataType {
+    constructor(subtype = 'int4range') {
+        super();
+        this.key = 'RANGE';
+        this.subtype = subtype;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return this.subtype;
+            case 'mysql':
+            case 'mariadb':
+            case 'sqlite':
+            default:
+                // Range types not supported, use VARCHAR as fallback
+                return 'VARCHAR(255)';
+        }
+    }
+}
+exports.RANGE = RANGE;
+// INET - PostgreSQL IP address type
+//
+// PostgreSQL's own `INET` column stores either an IPv4 or IPv6 address (and
+// doesn't need to know which up front), so `version` only matters for
+// dialects - like ClickHouse - that have genuinely distinct fixed-width
+// IPv4/IPv6 column types (`IPv4` vs `IPv6`) rather than one type that holds
+// either. Defaults to `4` to preserve the previous unconditional `VARCHAR(45)`
+// /`IPv4`-shaped behavior for existing callers that don't pass a version.
+class INET extends AbstractDataType {
+    constructor(options) {
+        super();
+        this.key = 'INET';
+        const version = typeof options === 'number' ? options : options?.version;
+        this.version = version === 6 ? 6 : 4;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'INET';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: No INET type, use VARCHAR
+                return 'VARCHAR(45)';
+            case 'sqlite':
+                // SQLite: No INET type, use TEXT
+                return 'TEXT';
+            default:
+                return 'VARCHAR(45)';
+        }
+    }
+}
+exports.INET = INET;
+// CIDR - PostgreSQL network address type
+class CIDR extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'CIDR';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'CIDR';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: No CIDR type, use VARCHAR
+                return 'VARCHAR(45)';
+            case 'sqlite':
+                // SQLite: No CIDR type, use TEXT
+                return 'TEXT';
+            default:
+                return 'VARCHAR(45)';
+        }
+    }
+}
+exports.CIDR = CIDR;
+// MACADDR - PostgreSQL MAC address type
+class MACADDR extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'MACADDR';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'MACADDR';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: No MACADDR type, use VARCHAR
+                return 'VARCHAR(17)';
+            case 'sqlite':
+                // SQLite: No MACADDR type, use TEXT
+                return 'TEXT';
+            default:
+                return 'VARCHAR(17)';
+        }
+    }
+}
+exports.MACADDR = MACADDR;
+// BINARY - fixed-length binary data
+class BINARY extends AbstractDataType {
+    constructor(length = 1) {
+        super();
+        this.key = 'BINARY';
+        this.length = length;
+    }
+    toSqlString(dialect) {
+        // MySQL/MariaDB use BINARY
+        if (dialect === 'mysql' || dialect === 'mariadb') {
+            return `BINARY(${this.length})`;
+        }
+        // SQLite uses BLOB for binary data
+        return `BLOB`;
+    }
+}
+exports.BINARY = BINARY;
+// VARBINARY - variable-length binary data
+class VARBINARY extends AbstractDataType {
+    constructor(length = 255) {
+        super();
+        this.key = 'VARBINARY';
+        this.length = length;
+    }
+    toSqlString(dialect) {
+        // MySQL/MariaDB use VARBINARY
+        if (dialect === 'mysql' || dialect === 'mariadb') {
+            return `VARBINARY(${this.length})`;
+        }
+        // SQLite uses BLOB for binary data
+        return `BLOB`;
+    }
+}
+exports.VARBINARY = VARBINARY;
+// BLOB types - binary data storage with dialect-specific handling
+class BLOB extends AbstractDataType {
+    constructor(length) {
+        super();
+        this.key = 'BLOB';
+        this.length = length;
+    }
+    /**
+     * Get the BLOB type string based on length variant
+     * MySQL/MariaDB format: TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB
+     */
+    getBlobType() {
+        if (!this.length) {
+            return 'BLOB';
+        }
+        // MySQL/MariaDB format: TINYBLOB, MEDIUMBLOB, LONGBLOB
+        if (this.length === 'tiny')
+            return 'TINYBLOB';
+        if (this.length === 'medium')
+            return 'MEDIUMBLOB';
+        if (this.length === 'long')
+            return 'LONGBLOB';
+        return 'BLOB';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL uses BYTEA for binary data
+                return 'BYTEA';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB support TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB
+                return this.getBlobType();
+            case 'sqlite':
+                // SQLite uses BLOB for all binary data
+                return 'BLOB';
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server uses VARBINARY(MAX) for binary data
+                return 'VARBINARY(MAX)';
+            default:
+                // Default to standard BLOB
+                return this.getBlobType();
+        }
+    }
+}
+exports.BLOB = BLOB;
+// Convenience classes for specific BLOB types
+class TINYBLOB extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'TINYBLOB';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'BYTEA';
+            case 'mysql':
+            case 'mariadb':
+                return 'TINYBLOB';
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+                return 'BLOB';
+            default:
+                return 'TINYBLOB';
+        }
+    }
+}
+exports.TINYBLOB = TINYBLOB;
+class MEDIUMBLOB extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'MEDIUMBLOB';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'BYTEA';
+            case 'mysql':
+            case 'mariadb':
+                return 'MEDIUMBLOB';
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+                return 'VARBINARY(MAX)';
+            default:
+                return 'MEDIUMBLOB';
+        }
+    }
+}
+exports.MEDIUMBLOB = MEDIUMBLOB;
+class LONGBLOB extends AbstractDataType {
+    constructor() {
+        super(...arguments);
+        this.key = 'LONGBLOB';
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                return 'BYTEA';
+            case 'mysql':
+            case 'mariadb':
+                return 'LONGBLOB';
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+                return 'VARBINARY(MAX)';
+            default:
+                return 'LONGBLOB';
+        }
+    }
+}
+exports.LONGBLOB = LONGBLOB;
+// ENUM
+class ENUM extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'ENUM';
+        // Handle both array and spread arguments
+        if (values.length === 1 && Array.isArray(values[0])) {
+            this.values = values[0];
+        }
+        else {
+            this.values = values;
+        }
+    }
+    /**
+     * Set a name for the enum type (useful for PostgreSQL/MySQL)
+     */
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    toSqlString(dialect) {
+        const valuesStr = this.values.map((v) => `'${v}'`).join(', ');
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL supports native ENUM type
+                if (this.name) {
+                    return `VARCHAR(255)`; // Will be created as ENUM type separately
+                }
+                return `VARCHAR(255)`;
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB support native ENUM type
+                return `ENUM(${valuesStr})`;
+            case 'sqlite':
+            default:
+                // SQLite uses TEXT with validation
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the values for validation
+     */
+    getValues() {
+        return [...this.values];
+    }
+    /**
+     * Validate if a value is valid for this ENUM
+     */
+    validate(value) {
+        return this.values.includes(value);
+    }
+    /**
+     * Generate an ALTER TABLE statement to add/modify ENUM column
+     * Note: MySQL uses MODIFY COLUMN, PostgreSQL needs type recreation
+     */
+    toAlterTableSql(dialect, tableName, columnName, _columnDefinition) {
+        const valuesStr = this.values.map((v) => `'${v}'`).join(', ');
+        switch (dialect) {
+            case 'mysql':
+            case 'mariadb':
+                return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\` ENUM(${valuesStr})`;
+            case 'postgres': {
+                // PostgreSQL requires creating the type first, then altering the column
+                const typeName = this.name || `${tableName}_${columnName}_type`;
+                return `-- PostgreSQL requires manual type creation:
+DROP TYPE IF EXISTS ${typeName};
+CREATE TYPE ${typeName} AS ENUM (${valuesStr});
+ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${typeName};
+ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT '${this.values[0]}';`;
+            }
+            default:
+                return `-- ENUM not supported for ${dialect}, using TEXT`;
+        }
+    }
+}
+exports.ENUM = ENUM;
+// ARRAY - PostgreSQL native arrays with fallback to JSON/TEXT for other dialects
+class ARRAY extends 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) {
+        super();
+        this.key = 'ARRAY';
+        this.type = type;
+    }
+    /**
+     * 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) {
+        // Get the base type for the element, passing the dialect through so nested
+        // types (e.g. STRING(50), DECIMAL(10,2)) resolve correctly per-dialect
+        const elementType = this.type.toSqlString(dialect);
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL supports native arrays with element type + []
+                return `${elementType}[]`;
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB: Use JSON type for arrays
+                return 'JSON';
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+            default:
+                // SQLite and SQL Server: Store as TEXT (JSON serialized)
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the element type
+     */
+    getElementType() {
+        return this.type;
+    }
+}
+exports.ARRAY = ARRAY;
+// LIST - DuckDB native variable-length list type, with fallback to JSON/TEXT
+// for dialects without a composite list type. Distinct from ARRAY: ARRAY is
+// modeled on PostgreSQL's fixed-element-type array (and mainly documents
+// PostgreSQL-native `[]` syntax with generic fallbacks), whereas LIST maps
+// onto DuckDB's `<type>[]` LIST columns specifically and is the type callers
+// should reach for when targeting DuckDB's composite type system.
+class LIST extends 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) {
+        super();
+        this.key = 'LIST';
+        this.type = type;
+    }
+    /**
+     * Get the SQL string representation based on the dialect
+     * DuckDB/PostgreSQL: native `elementType[]` syntax
+     * Other dialects: falls back to JSON or TEXT
+     */
+    toSqlString(dialect) {
+        const elementType = this.type.toSqlString(dialect);
+        switch (dialect) {
+            case 'duckdb':
+            case 'postgres':
+                return `${elementType}[]`;
+            case 'mysql':
+            case 'mariadb':
+                return 'JSON';
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the element type
+     */
+    getElementType() {
+        return this.type;
+    }
+}
+exports.LIST = LIST;
+// STRUCT - DuckDB native nested record type (named fields with heterogeneous
+// types), with fallback to JSON/TEXT for dialects without a composite struct type.
+class STRUCT extends 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) {
+        super();
+        this.key = 'STRUCT';
+        this.fields = fields;
+    }
+    /**
+     * 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) {
+        switch (dialect) {
+            case 'duckdb': {
+                const parts = Object.entries(this.fields).map(([name, type]) => `${name} ${type.toSqlString(dialect)}`);
+                return `STRUCT(${parts.join(', ')})`;
+            }
+            case 'mysql':
+            case 'mariadb':
+                return 'JSON';
+            case 'postgres':
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the struct's fields
+     */
+    getFields() {
+        return this.fields;
+    }
+}
+exports.STRUCT = STRUCT;
+// MAP - DuckDB native key/value map type (homogeneous key type, homogeneous
+// value type, unlike STRUCT), with fallback to JSON/TEXT for other dialects.
+class MAP extends 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, valueType) {
+        super();
+        this.key = 'MAP';
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+    /**
+     * 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) {
+        switch (dialect) {
+            case 'duckdb':
+                return `MAP(${this.keyType.toSqlString(dialect)}, ${this.valueType.toSqlString(dialect)})`;
+            case 'mysql':
+            case 'mariadb':
+                return 'JSON';
+            case 'postgres':
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the map's key type
+     */
+    getKeyType() {
+        return this.keyType;
+    }
+    /**
+     * Get the map's value type
+     */
+    getValueType() {
+        return this.valueType;
+    }
+}
+exports.MAP = MAP;
+// UNION - DuckDB native tagged-union type (exactly one of several named
+// alternative types is active at a time), with fallback to JSON/TEXT for
+// other dialects. Not to be confused with the SQL `UNION` query operator.
+class DUCKDB_UNION extends 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) {
+        super();
+        this.key = 'UNION';
+        this.fields = fields;
+    }
+    /**
+     * 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) {
+        switch (dialect) {
+            case 'duckdb': {
+                const parts = Object.entries(this.fields).map(([tag, type]) => `${tag} ${type.toSqlString(dialect)}`);
+                return `UNION(${parts.join(', ')})`;
+            }
+            case 'mysql':
+            case 'mariadb':
+                return 'JSON';
+            case 'postgres':
+            case 'sqlite':
+            case 'mssql':
+            case 'sqlserver':
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the union's member fields
+     */
+    getFields() {
+        return this.fields;
+    }
+}
+exports.DUCKDB_UNION = DUCKDB_UNION;
+/**
+ * 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)
+ */
+class GEOMETRY extends AbstractDataType {
+    constructor(typeOrOptions, srid) {
+        super();
+        this.key = 'GEOMETRY';
+        if (typeof typeOrOptions === 'object' && typeOrOptions !== null) {
+            // Called with options object: GEOMETRY({ type: 'POINT', srid: 4326 })
+            this.type = typeOrOptions.type;
+            this.srid = typeOrOptions.srid;
+        }
+        else {
+            // Called with positional args: GEOMETRY('POINT', 4326)
+            this.type = typeOrOptions;
+            this.srid = srid;
+        }
+    }
+    /**
+     * Get the geometry type in uppercase
+     */
+    getGeometryType() {
+        return this.type?.toUpperCase();
+    }
+    toSqlString(dialect) {
+        const typeStr = this.type ? this.type.toUpperCase() : '';
+        const sridStr = this.srid ? `, ${this.srid}` : '';
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL with PostGIS extension
+                if (typeStr && sridStr) {
+                    return `GEOMETRY(${typeStr}${sridStr})`;
+                }
+                else if (typeStr) {
+                    return `GEOMETRY(${typeStr})`;
+                }
+                return 'GEOMETRY';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB spatial types
+                if (typeStr && sridStr) {
+                    return `${typeStr}${sridStr}`;
+                }
+                else if (typeStr) {
+                    return typeStr;
+                }
+                return 'GEOMETRY';
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server uses geography/geometry types
+                if (typeStr) {
+                    return `geometry`;
+                }
+                return 'geometry';
+            case 'sqlite':
+            default:
+                // SQLite stores spatial data as BLOB (GeoJSON or WKB)
+                return 'BLOB';
+        }
+    }
+}
+exports.GEOMETRY = GEOMETRY;
+/**
+ * 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)
+ */
+class GEOGRAPHY extends AbstractDataType {
+    constructor(typeOrOptions, srid) {
+        super();
+        this.key = 'GEOGRAPHY';
+        if (typeof typeOrOptions === 'object' && typeOrOptions !== null) {
+            // Called with options object: GEOGRAPHY({ type: 'POLYGON', srid: 4326 })
+            this.type = typeOrOptions.type;
+            this.srid = typeOrOptions.srid;
+        }
+        else {
+            // Called with positional args: GEOGRAPHY('POLYGON', 4326)
+            this.type = typeOrOptions;
+            this.srid = srid;
+        }
+        // Default to WGS84 (SRID 4326) if not specified
+        if (this.srid === undefined) {
+            this.srid = 4326;
+        }
+    }
+    /**
+     * Get the geography type in uppercase
+     */
+    getGeographyType() {
+        return this.type?.toUpperCase();
+    }
+    /**
+     * Get the SRID (defaults to 4326 for WGS84)
+     */
+    getSRID() {
+        return this.srid || 4326;
+    }
+    toSqlString(dialect) {
+        const typeStr = this.type ? this.type.toUpperCase() : '';
+        const sridStr = this.srid ? `, ${this.srid}` : '';
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL with PostGIS - GEOGRAPHY is preferred for geographic data
+                if (typeStr && sridStr) {
+                    return `GEOGRAPHY(${typeStr}${sridStr})`;
+                }
+                else if (typeStr) {
+                    return `GEOGRAPHY(${typeStr})`;
+                }
+                // Default geography defaults to GEOGRAPHY(GEOMETRY, 4326)
+                return 'GEOGRAPHY';
+            case 'mysql':
+            case 'mariadb':
+                // MySQL 8.0+ supports GEOGRAPHY type
+                if (typeStr) {
+                    return typeStr;
+                }
+                return 'GEOMETRY'; // MySQL treats geography as geometry
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server geography type (uses WGS84 by default)
+                if (typeStr) {
+                    return `geography`;
+                }
+                return 'geography';
+            case 'sqlite':
+            default:
+                // SQLite stores spatial data as BLOB
+                return 'BLOB';
+        }
+    }
+}
+exports.GEOGRAPHY = GEOGRAPHY;
+/**
+ * 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)
+ */
+class POINT extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'POINT';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(POINT, ${this.srid})`;
+                }
+                return 'GEOMETRY(POINT)';
+            case 'mysql':
+            case 'mariadb':
+                return 'POINT';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.POINT = POINT;
+/**
+ * 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)
+ */
+class LINESTRING extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'LINESTRING';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(LINESTRING, ${this.srid})`;
+                }
+                return 'GEOMETRY(LINESTRING)';
+            case 'mysql':
+            case 'mariadb':
+                return 'LINESTRING';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.LINESTRING = LINESTRING;
+/**
+ * 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)
+ */
+class POLYGON extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'POLYGON';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(POLYGON, ${this.srid})`;
+                }
+                return 'GEOMETRY(POLYGON)';
+            case 'mysql':
+            case 'mariadb':
+                return 'POLYGON';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.POLYGON = POLYGON;
+// MULTIPOINT - MySQL spatial type for collections of points
+class MULTIPOINT extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'MULTIPOINT';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(MULTIPOINT, ${this.srid})`;
+                }
+                return 'GEOMETRY(MULTIPOINT)';
+            case 'mysql':
+            case 'mariadb':
+                return 'MULTIPOINT';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.MULTIPOINT = MULTIPOINT;
+// MULTILINESTRING - MySQL spatial type for collections of lines
+class MULTILINESTRING extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'MULTILINESTRING';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(MULTILINESTRING, ${this.srid})`;
+                }
+                return 'GEOMETRY(MULTILINESTRING)';
+            case 'mysql':
+            case 'mariadb':
+                return 'MULTILINESTRING';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.MULTILINESTRING = MULTILINESTRING;
+// MULTIPOLYGON - MySQL spatial type for collections of polygons
+class MULTIPOLYGON extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'MULTIPOLYGON';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(MULTIPOLYGON, ${this.srid})`;
+                }
+                return 'GEOMETRY(MULTIPOLYGON)';
+            case 'mysql':
+            case 'mariadb':
+                return 'MULTIPOLYGON';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.MULTIPOLYGON = MULTIPOLYGON;
+// GEOMETRYCOLLECTION - MySQL spatial type for heterogeneous geometry collections
+class GEOMETRYCOLLECTION extends AbstractDataType {
+    constructor(srid) {
+        super();
+        this.key = 'GEOMETRYCOLLECTION';
+        this.srid = srid;
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'postgres':
+                if (this.srid) {
+                    return `GEOMETRY(GEOMETRYCOLLECTION, ${this.srid})`;
+                }
+                return 'GEOMETRY(GEOMETRYCOLLECTION)';
+            case 'mysql':
+            case 'mariadb':
+                return 'GEOMETRYCOLLECTION';
+            case 'mssql':
+            case 'sqlserver':
+                return 'geometry';
+            case 'sqlite':
+            default:
+                return 'BLOB';
+        }
+    }
+}
+exports.GEOMETRYCOLLECTION = GEOMETRYCOLLECTION;
+// SET - MySQL SET column type for storing multiple values from a set
+class SET extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'SET';
+        // Handle both array and spread arguments
+        if (values.length === 1 && Array.isArray(values[0])) {
+            this.values = values[0];
+        }
+        else {
+            this.values = values;
+        }
+    }
+    toSqlString(dialect) {
+        const valuesStr = this.values.map((v) => `'${v}'`).join(', ');
+        switch (dialect) {
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB support native SET type
+                return `SET(${valuesStr})`;
+            case 'postgres':
+            case 'sqlite':
+            default:
+                // Other dialects use TEXT with validation
+                return 'TEXT';
+        }
+    }
+    /**
+     * Get the values for validation
+     */
+    getValues() {
+        return [...this.values];
+    }
+    /**
+     * Validate if a value is valid for this SET
+     */
+    validate(value) {
+        return this.values.includes(value);
+    }
+}
+exports.SET = SET;
+// JSONColumn - MySQL native JSON column type
+class JSONColumn extends AbstractDataType {
+    /**
+     * 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) {
+        super();
+        this.key = 'JSONCOLUMN';
+        if (options) {
+            this.validate = options.validate;
+            this.unescapedUnicode = options.unescapedUnicode;
+            this.compact = options.compact;
+        }
+    }
+    toSqlString(dialect) {
+        switch (dialect) {
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB native JSON type
+                return 'JSON';
+            case 'postgres':
+                // PostgreSQL uses JSONB for better performance
+                return 'JSONB';
+            case 'sqlite':
+                return 'TEXT';
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server uses NVARCHAR(MAX) for JSON
+                return 'NVARCHAR(MAX)';
+            default:
+                return 'TEXT';
+        }
+    }
+}
+exports.JSONColumn = JSONColumn;
+class VIRTUAL extends AbstractDataType {
+    constructor(options) {
+        super();
+        this.key = 'VIRTUAL';
+        if (options) {
+            this.returnType = options.returnType;
+            this.get = options.get;
+            this.set = options.set;
+            this.dependencies = options.dependencies;
+        }
+    }
+    toSqlString() {
+        // Virtual fields don't create a database column
+        return '';
+    }
+    /**
+     * Check if this virtual field has a getter
+     */
+    hasGetter() {
+        return typeof this.get === 'function';
+    }
+    /**
+     * Check if this virtual field has a setter
+     */
+    hasSetter() {
+        return typeof this.set === 'function';
+    }
+    /**
+     * Get the dependencies for this virtual field
+     */
+    getDependencies() {
+        return this.dependencies || [];
+    }
+}
+exports.VIRTUAL = VIRTUAL;
+/**
+ * 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
+ * })
+ */
+class VIRTUALSTRING extends AbstractDataType {
+    constructor(options) {
+        super();
+        this.key = 'VIRTUALSTRING';
+        if (options) {
+            this.get = options.get;
+            this.set = options.set;
+            this.length = options.length;
+            this.dependencies = options.dependencies;
+        }
+    }
+    toSqlString() {
+        // Virtual fields don't create a database column
+        return '';
+    }
+    /**
+     * Check if this virtual string field has a getter
+     */
+    hasGetter() {
+        return typeof this.get === 'function';
+    }
+    /**
+     * Check if this virtual string field has a setter
+     */
+    hasSetter() {
+        return typeof this.set === 'function';
+    }
+    /**
+     * Get the dependencies for this virtual field
+     */
+    getDependencies() {
+        return this.dependencies || [];
+    }
+    /**
+     * Get the maximum length for validation
+     */
+    getLength() {
+        return this.length;
+    }
+}
+exports.VIRTUALSTRING = VIRTUALSTRING;
+/**
+ * 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);
+ *   }
+ * })
+ */
+class ALGORITHM extends AbstractDataType {
+    /**
+     * Get the default cost/rounds for each algorithm
+     */
+    getDefaultCost() {
+        switch (this.algorithm) {
+            case 'BCRYPT':
+                return 10;
+            case 'ARGON2':
+                return 65536; // memory cost in KB
+            case 'PBKDF2':
+                return 100000;
+            case 'SCRYPT':
+                return 16384;
+            default:
+                return 0;
+        }
+    }
+    /**
+     * Get the output length for each algorithm (in characters for VARCHAR)
+     * This accounts for the full hash including prefixes, salts, etc.
+     */
+    getOutputLength() {
+        switch (this.algorithm) {
+            case 'MD5':
+                return 32; // 32 hex characters
+            case 'SHA1':
+                return 40; // 40 hex characters
+            case 'SHA256':
+                return 64; // 64 hex characters
+            case 'SHA384':
+                return 96; // 96 hex characters
+            case 'SHA512':
+                return 128; // 128 hex characters
+            case 'SHA512_256':
+                return 64; // 64 hex characters
+            case 'BCRYPT':
+                return 60; // $2a$10$ + 53 characters
+            case 'ARGON2':
+                return 128; // $argon2id$v=19$m=65536,t=3,p=2$ + salt + hash
+            case 'PBKDF2':
+                return this.hashLength ? this.hashLength * 2 : 128; // Hex encoded
+            case 'SCRYPT':
+                return 128; // Variable length
+            case 'NTLM':
+                return 32; // 32 hex characters
+            case 'MYSQL':
+                return 40; // 40 hex characters
+            case 'POSTGRESQL_MD5':
+                return 35; // md5( + 32 hex + )
+            default:
+                return 64;
+        }
+    }
+    constructor(options) {
+        super();
+        this.key = 'ALGORITHM';
+        this.algorithm = options.algorithm;
+        this.cost = options.cost ?? (options.algorithm ? this.getDefaultCost() : undefined);
+        this.saltLength = options.saltLength;
+        this.hashLength = options.hashLength;
+        this.includeSalt = options.includeSalt ?? true;
+        this.parallelism = options.parallelism ?? 1;
+        this.blockSize = options.blockSize ?? 8;
+    }
+    /**
+     * Get the algorithm name
+     */
+    getAlgorithm() {
+        return this.algorithm;
+    }
+    /**
+     * Check if this is a password hashing algorithm (slow hash)
+     * Password hashing algorithms are designed to be slow to prevent brute force
+     */
+    isPasswordHash() {
+        return ['BCRYPT', 'ARGON2', 'PBKDF2', 'SCRYPT'].includes(this.algorithm);
+    }
+    /**
+     * Check if this is a fast hash algorithm (checksums)
+     */
+    isFastHash() {
+        return ['MD5', 'SHA1', 'SHA256', 'SHA384', 'SHA512', 'SHA512_256', 'NTLM'].includes(this.algorithm);
+    }
+    /**
+     * Get the configuration object for hashing libraries
+     */
+    getHashConfig() {
+        const config = {
+            algorithm: this.algorithm,
+        };
+        if (this.cost) {
+            if (this.algorithm === 'BCRYPT') {
+                config.rounds = this.cost;
+            }
+            else if (this.algorithm === 'ARGON2') {
+                config.memoryCost = this.cost;
+            }
+            else if (this.algorithm === 'PBKDF2') {
+                config.iterations = this.cost;
+            }
+            else if (this.algorithm === 'SCRYPT') {
+                config.cost = this.cost;
+            }
+        }
+        if (this.saltLength) {
+            config.saltLength = this.saltLength;
+        }
+        if (this.hashLength) {
+            config.hashLength = this.hashLength;
+        }
+        if (this.parallelism && this.algorithm === 'ARGON2') {
+            config.parallelism = this.parallelism;
+        }
+        if (this.blockSize && this.algorithm === 'ARGON2') {
+            config.blockSize = this.blockSize;
+        }
+        return config;
+    }
+    toSqlString(dialect) {
+        const length = this.getOutputLength();
+        // For most databases, use VARCHAR with appropriate length
+        // Some databases support native password hash types
+        switch (dialect) {
+            case 'postgres':
+                // PostgreSQL doesn't have specific hash types, use VARCHAR
+                return `VARCHAR(${length})`;
+            case 'mysql':
+            case 'mariadb':
+                // MySQL/MariaDB - use VARCHAR for password hashes
+                return `VARCHAR(${length})`;
+            case 'sqlite':
+                // SQLite uses TEXT for variable-length strings
+                return `TEXT`;
+            case 'mssql':
+            case 'sqlserver':
+                // SQL Server uses NVARCHAR
+                return `NVARCHAR(${length})`;
+            default:
+                return `VARCHAR(${length})`;
+        }
+    }
+}
+exports.ALGORITHM = ALGORITHM;
+/**
+ * VIRTUAL with ALGORITHM - computed hash field
+ * Useful for automatic password hashing when setting values
+ *
+ * @example
+ * // Auto-hash password on set using BCRYPT
+ * passwordHash: DataTypes.VIRTUAL({
+ *   returnType: DataTypes.ALGORITHM({ algorithm: 'BCRYPT', cost: 12 }),
+ *   set(value: string) {
+ *     this._passwordHash = bcrypt.hashSync(value, 12);
+ *   },
+ *   get() {
+ *     return this._passwordHash;
+ *   }
+ * })
+ *
+ * // Verify password (comparison virtual field)
+ * password: DataTypes.STRING(255),
+ * passwordConfirm: DataTypes.VIRTUAL({
+ *   returnType: DataTypes.BOOLEAN(),
+ *   set(value: string) {
+ *     // This will be handled by the model validation
+ *   }
+ * })
+ */
+// Helper to add static toSql, equals, and serialize methods to factory functions while preserving call signature
+function createDataTypeFactory(factory, key) {
+    const factoryFn = factory;
+    // Attach the key to the factory function for comparison
+    factoryFn.key = key;
+    factoryFn.toSql = function () { return factory().toSql(); };
+    // Static equals method for comparing DataType factories
+    factoryFn.equals = function (other) {
+        if (!other) {
+            return false;
+        }
+        // If it's a factory function with a key property, compare by key
+        if (typeof other === 'function' && other.key) {
+            return other.key === key;
+        }
+        // If it's an object with key property (like a DataType instance)
+        if (typeof other === 'object' && other.key) {
+            return other.key === key;
+        }
+        // If it's a string, compare directly
+        if (typeof other === 'string') {
+            return other === key;
+        }
+        return false;
+    };
+    // Static serialize method for serializing values
+    factoryFn.serialize = function (value) {
+        return value;
+    };
+    return factoryFn;
+}
+// Export DataTypes object with all data types
+exports.DataTypes = {
+    STRING: createDataTypeFactory((length, binary = false) => new STRING(length, binary), 'STRING'),
+    VARCHAR: createDataTypeFactory((length = 255) => new VARCHAR(length), 'VARCHAR'),
+    CHAR: createDataTypeFactory((length = 1) => new CHAR(length), 'CHAR'),
+    TEXT: createDataTypeFactory((length) => new TEXT(length), 'TEXT'),
+    TINYTEXT: createDataTypeFactory(() => new TINYTEXT(), 'TINYTEXT'),
+    MEDIUMTEXT: createDataTypeFactory(() => new MEDIUMTEXT(), 'MEDIUMTEXT'),
+    LONGTEXT: createDataTypeFactory(() => new LONGTEXT(), 'LONGTEXT'),
+    INTEGER: createDataTypeFactory((options) => new INTEGER(options || {}), 'INTEGER'),
+    TINYINT: createDataTypeFactory((options) => new TINYINT(options || {}), 'TINYINT'),
+    SMALLINT: createDataTypeFactory((options) => new SMALLINT(options || {}), 'SMALLINT'),
+    MEDIUMINT: createDataTypeFactory((options) => new MEDIUMINT(options || {}), 'MEDIUMINT'),
+    BIGINT: createDataTypeFactory((options) => new BIGINT(options || {}), 'BIGINT'),
+    FLOAT: createDataTypeFactory((precisionOrOptions) => new FLOAT(precisionOrOptions), 'FLOAT'),
+    DOUBLE: createDataTypeFactory((precisionOrOptions) => new DOUBLE(precisionOrOptions), 'DOUBLE'),
+    DECIMAL: createDataTypeFactory((precision = 10, scale = 0, unsigned = false) => new DECIMAL(precision, scale, unsigned), 'DECIMAL'),
+    REAL: createDataTypeFactory((precisionOrOptions) => new REAL(precisionOrOptions), 'REAL'),
+    BOOLEAN: createDataTypeFactory(() => new BOOLEAN(), 'BOOLEAN'),
+    DATE: createDataTypeFactory((precision, timezone = false) => new DATE(precision, timezone), 'DATE'),
+    DATEONLY: createDataTypeFactory(() => new DATEONLY(), 'DATEONLY'),
+    DATETIME: createDataTypeFactory((precision) => new DATETIME(precision), 'DATETIME'),
+    TIMESTAMP: createDataTypeFactory((precision) => new TIMESTAMP(precision), 'TIMESTAMP'),
+    NOW: createDataTypeFactory(() => new NOW(), 'NOW'),
+    TIME: createDataTypeFactory((precision, timezone = false) => new TIME(precision, timezone), 'TIME'),
+    UUID: createDataTypeFactory(() => new UUID(), 'UUID'),
+    UUIDV1: createDataTypeFactory(() => new UUIDV1(), 'UUIDV1'),
+    UUIDV4: createDataTypeFactory(() => new UUIDV4(), 'UUIDV4'),
+    JSON: createDataTypeFactory((useNative = false) => new JSON(useNative), 'JSON'),
+    JSONB: createDataTypeFactory((useNative = false) => new JSONB(useNative), 'JSONB'),
+    // PostgreSQL-specific types
+    HSTORE: createDataTypeFactory((useNative = true) => new HSTORE(useNative), 'HSTORE'),
+    RANGE: createDataTypeFactory((subtype) => new RANGE(subtype), 'RANGE'),
+    INET: createDataTypeFactory((options) => new INET(options), 'INET'),
+    // Convenience factory for an IPv6-specific INET column, e.g.
+    // `DataTypes.INET6` instead of `DataTypes.INET({ version: 6 })`. Dialects
+    // with a distinct IPv6 column type (e.g. ClickHouse's `IPv6`) key off
+    // `INET.version`, which this sets to `6`; dialects that only have one
+    // "INET" type (Postgres) render identically either way.
+    INET6: createDataTypeFactory(() => new INET({ version: 6 }), 'INET'),
+    CIDR: createDataTypeFactory(() => new CIDR(), 'CIDR'),
+    MACADDR: createDataTypeFactory(() => new MACADDR(), 'MACADDR'),
+    BLOB: createDataTypeFactory((length) => new BLOB(length), 'BLOB'),
+    TINYBLOB: createDataTypeFactory(() => new TINYBLOB(), 'TINYBLOB'),
+    MEDIUMBLOB: createDataTypeFactory(() => new MEDIUMBLOB(), 'MEDIUMBLOB'),
+    LONGBLOB: createDataTypeFactory(() => new LONGBLOB(), 'LONGBLOB'),
+    BINARY: createDataTypeFactory((length = 1) => new BINARY(length), 'BINARY'),
+    VARBINARY: createDataTypeFactory((length = 255) => new VARBINARY(length), 'VARBINARY'),
+    /**
+     * 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: createDataTypeFactory((...values) => new ENUM(...values), 'ENUM'),
+    ARRAY: createDataTypeFactory((type) => new ARRAY(type), 'ARRAY'),
+    /**
+     * LIST data type - DuckDB native variable-length list (`elementType[]`)
+     * @param type - The data type of list elements
+     * @example
+     * tags: DataTypes.LIST(DataTypes.INTEGER)
+     */
+    LIST: createDataTypeFactory((type) => new LIST(type), 'LIST'),
+    /**
+     * 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: createDataTypeFactory((fields) => new STRUCT(fields), 'STRUCT'),
+    /**
+     * 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: createDataTypeFactory((keyType, valueType) => new MAP(keyType, valueType), 'MAP'),
+    /**
+     * 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: createDataTypeFactory((fields) => new DUCKDB_UNION(fields), 'UNION'),
+    GEOMETRY: createDataTypeFactory((type, srid) => new GEOMETRY(type, srid), 'GEOMETRY'),
+    GEOGRAPHY: createDataTypeFactory((type, srid) => new GEOGRAPHY(type, srid), 'GEOGRAPHY'),
+    POINT: createDataTypeFactory((srid) => new POINT(srid), 'POINT'),
+    LINESTRING: createDataTypeFactory((srid) => new LINESTRING(srid), 'LINESTRING'),
+    POLYGON: createDataTypeFactory((srid) => new POLYGON(srid), 'POLYGON'),
+    MULTIPOINT: createDataTypeFactory((srid) => new MULTIPOINT(srid), 'MULTIPOINT'),
+    MULTILINESTRING: createDataTypeFactory((srid) => new MULTILINESTRING(srid), 'MULTILINESTRING'),
+    MULTIPOLYGON: createDataTypeFactory((srid) => new MULTIPOLYGON(srid), 'MULTIPOLYGON'),
+    GEOMETRYCOLLECTION: createDataTypeFactory((srid) => new GEOMETRYCOLLECTION(srid), 'GEOMETRYCOLLECTION'),
+    SET: createDataTypeFactory((...values) => new SET(...values), 'SET'),
+    JSONCOLUMN: createDataTypeFactory((options) => new JSONColumn(options), 'JSONCOLUMN'),
+    VIRTUAL: createDataTypeFactory((options) => new VIRTUAL(options), 'VIRTUAL'),
+    VIRTUALSTRING: createDataTypeFactory((options) => new VIRTUALSTRING(options), 'VIRTUALSTRING'),
+    /**
+     * 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: createDataTypeFactory((options) => new ALGORITHM(options), 'ALGORITHM'),
+};
+/**
+ * Static convenience modifiers, mirroring the chainable instance modifiers
+ * (e.g. `DataTypes.INTEGER().UNSIGNED()`) as pre-built instances so they can
+ * also be accessed directly off the type factory (e.g. `DataTypes.INTEGER.UNSIGNED`).
+ */
+exports.DataTypes.INTEGER.UNSIGNED = new INTEGER({
+    unsigned: true,
+});
+exports.DataTypes.INTEGER.ZEROFILL = new INTEGER({
+    zerofill: true,
+});
+// STRING has no UNSIGNED/ZEROFILL semantics in SQL (those only apply to numeric types),
+// but the property is exposed as a harmless pass-through for API parity.
+exports.DataTypes.STRING.UNSIGNED = new STRING();
+exports.DataTypes.STRING.ZEROFILL = new STRING();
+// BOOLEAN is commonly stored as TINYINT(1) (this is what MySQL/MariaDB already do
+// under the hood for BOOLEAN columns), exposed here for explicit opt-in.
+exports.DataTypes.BOOLEAN.TINYINT = new TINYINT({ length: 1 });
+// DATE-family convenience aliases
+exports.DataTypes.DATE.TIMESTAMP = new TIMESTAMP();
+exports.DataTypes.DATE.DATEONLY = new DATEONLY();
+exports.DataTypes.DATE.TIME = new TIME();