@dockstat/sqlite-wrapper 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -1,52 +1,401 @@
 // Generated by dts-bundle-generator v9.5.1
 
-import { Database } from 'bun:sqlite';
+import { Database, SQLQueryBindings } from 'bun:sqlite';
 
 /**
- * Utility types for query building
+ * All SQLite data types including affinity types
  */
-export type ColumnNames<T> = Array<keyof T> | [
+export declare const SQLiteTypes: {
+	readonly INTEGER: "INTEGER";
+	readonly TEXT: "TEXT";
+	readonly REAL: "REAL";
+	readonly BLOB: "BLOB";
+	readonly NUMERIC: "NUMERIC";
+	readonly INT: "INT";
+	readonly TINYINT: "TINYINT";
+	readonly SMALLINT: "SMALLINT";
+	readonly MEDIUMINT: "MEDIUMINT";
+	readonly BIGINT: "BIGINT";
+	readonly VARCHAR: "VARCHAR";
+	readonly CHAR: "CHAR";
+	readonly CHARACTER: "CHARACTER";
+	readonly NCHAR: "NCHAR";
+	readonly NVARCHAR: "NVARCHAR";
+	readonly CLOB: "CLOB";
+	readonly DOUBLE: "DOUBLE";
+	readonly FLOAT: "FLOAT";
+	readonly DECIMAL: "DECIMAL";
+	readonly DATE: "DATE";
+	readonly DATETIME: "DATETIME";
+	readonly TIMESTAMP: "TIMESTAMP";
+	readonly TIME: "TIME";
+	readonly BOOLEAN: "BOOLEAN";
+	readonly JSON: "JSON";
+};
+export type SQLiteType = (typeof SQLiteTypes)[keyof typeof SQLiteTypes];
+/**
+ * SQLite built-in scalar functions
+ */
+export declare const SQLiteFunctions: {
+	readonly DATE: (expr: string) => string;
+	readonly TIME: (expr: string) => string;
+	readonly DATETIME: (expr: string) => string;
+	readonly JULIANDAY: (expr: string) => string;
+	readonly STRFTIME: (format: string, expr: string) => string;
+	readonly LENGTH: (expr: string) => string;
+	readonly LOWER: (expr: string) => string;
+	readonly UPPER: (expr: string) => string;
+	readonly TRIM: (expr: string, chars?: string) => string;
+	readonly LTRIM: (expr: string, chars?: string) => string;
+	readonly RTRIM: (expr: string, chars?: string) => string;
+	readonly SUBSTR: (expr: string, start: number, length?: number) => string;
+	readonly SUBSTRING: (expr: string, start: number, length?: number) => string;
+	readonly REPLACE: (expr: string, old: string, replacement: string) => string;
+	readonly PRINTF: (format: string, ...args: string[]) => string;
+	readonly ABS: (expr: string) => string;
+	readonly ROUND: (expr: string, digits?: number) => string;
+	readonly RANDOM: () => string;
+	readonly MIN: (...exprs: string[]) => string;
+	readonly MAX: (...exprs: string[]) => string;
+	readonly CAST: (expr: string, type: string) => string;
+	readonly TYPEOF: (expr: string) => string;
+	readonly COALESCE: (...exprs: string[]) => string;
+	readonly IFNULL: (expr: string, replacement: string) => string;
+	readonly NULLIF: (expr1: string, expr2: string) => string;
+	readonly IIF: (condition: string, trueValue: string, falseValue: string) => string;
+	readonly COUNT: (expr?: string) => string;
+	readonly SUM: (expr: string) => string;
+	readonly AVG: (expr: string) => string;
+	readonly TOTAL: (expr: string) => string;
+	readonly GROUP_CONCAT: (expr: string, separator?: string) => string;
+	readonly JSON: (expr: string) => string;
+	readonly JSON_EXTRACT: (json: string, path: string) => string;
+	readonly JSON_TYPE: (json: string, path?: string) => string;
+	readonly JSON_VALID: (expr: string) => string;
+	readonly JSON_ARRAY: (...values: string[]) => string;
+	readonly JSON_OBJECT: (...pairs: string[]) => string;
+};
+/**
+ * SQLite keywords and special values
+ */
+export declare const SQLiteKeywords: {
+	readonly NULL: "NULL";
+	readonly CURRENT_TIME: "CURRENT_TIME";
+	readonly CURRENT_DATE: "CURRENT_DATE";
+	readonly CURRENT_TIMESTAMP: "CURRENT_TIMESTAMP";
+	readonly TRUE: "1";
+	readonly FALSE: "0";
+	readonly ROLLBACK: "ROLLBACK";
+	readonly ABORT: "ABORT";
+	readonly FAIL: "FAIL";
+	readonly IGNORE: "IGNORE";
+	readonly REPLACE: "REPLACE";
+};
+/**
+ * Foreign key actions
+ */
+export type ForeignKeyAction = "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+/**
+ * Column constraint options with comprehensive support
+ */
+export interface ColumnConstraints {
+	/** Column is PRIMARY KEY */
+	primaryKey?: boolean;
+	/** Column has AUTOINCREMENT (only valid with INTEGER PRIMARY KEY) */
+	autoincrement?: boolean;
+	/** Column is NOT NULL */
+	notNull?: boolean;
+	/** Column has UNIQUE constraint */
+	unique?: boolean;
+	/** Default value - can be literal value, function call, or keyword */
+	default?: string | number | boolean | null | DefaultExpression;
+	/** Custom check constraint */
+	check?: string;
+	/** Collation sequence */
+	collate?: "BINARY" | "NOCASE" | "RTRIM" | string;
+	/** References another table (foreign key) */
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: ForeignKeyAction;
+		onUpdate?: ForeignKeyAction;
+	};
+	/** Generated column expression (GENERATED ALWAYS AS) */
+	generated?: {
+		expression: string;
+		stored?: boolean;
+	};
+	/** Column comment (stored as metadata, not in schema) */
+	comment?: string;
+}
+/**
+ * Type-safe default value expressions
+ */
+export type DefaultExpression = {
+	_type: "expression";
+	expression: string;
+};
+/**
+ * Helper to create default expressions
+ */
+export declare const defaultExpr: (expression: string) => DefaultExpression;
+/**
+ * Type-safe column definition
+ */
+export interface ColumnDefinition extends ColumnConstraints {
+	/** SQLite data type */
+	type: SQLiteType;
+	/** Optional type parameters (e.g., VARCHAR(255)) */
+	length?: number;
+	/** Precision for DECIMAL/NUMERIC types */
+	precision?: number;
+	/** Scale for DECIMAL/NUMERIC types */
+	scale?: number;
+}
+/**
+ * Type-safe table schema definition
+ */
+export type TableSchema = Record<string, ColumnDefinition>;
+/**
+ * Table constraint types
+ */
+export interface TableConstraints {
+	/** PRIMARY KEY constraint on multiple columns */
+	primaryKey?: string[];
+	/** UNIQUE constraints */
+	unique?: string[] | string[][];
+	/** CHECK constraints */
+	check?: string[];
+	/** FOREIGN KEY constraints */
+	foreignKeys?: Array<{
+		columns: string[];
+		references: {
+			table: string;
+			columns: string[];
+			onDelete?: ForeignKeyAction;
+			onUpdate?: ForeignKeyAction;
+		};
+	}>;
+}
+/**
+ * Enhanced table options
+ */
+export interface TableOptions {
+	/** Add IF NOT EXISTS clause */
+	ifNotExists?: boolean;
+	/** Create WITHOUT ROWID table */
+	withoutRowId?: boolean;
+	/** Table constraints */
+	constraints?: TableConstraints;
+	/** Temporary table */
+	temporary?: boolean;
+	/** Table comment */
+	comment?: string;
+}
+/**
+ * Comprehensive column helper functions with full type support
+ */
+export declare const column: {
+	/**
+	 * Create an INTEGER column with optional size specification
+	 */
+	integer: (constraints?: ColumnConstraints & {
+		size?: "TINYINT" | "SMALLINT" | "MEDIUMINT" | "BIGINT";
+	}) => ColumnDefinition;
+	/**
+	 * Create a TEXT column with optional length
+	 */
+	text: (constraints?: ColumnConstraints & {
+		length?: number;
+		variant?: "VARCHAR" | "CHAR" | "CLOB" | "NCHAR" | "NVARCHAR";
+	}) => ColumnDefinition;
+	/**
+	 * Create a REAL column
+	 */
+	real: (constraints?: ColumnConstraints & {
+		variant?: "DOUBLE" | "FLOAT";
+	}) => ColumnDefinition;
+	/**
+	 * Create a BLOB column
+	 */
+	blob: (constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a NUMERIC/DECIMAL column with precision and scale
+	 */
+	numeric: (constraints?: ColumnConstraints & {
+		precision?: number;
+		scale?: number;
+		variant?: "DECIMAL";
+	}) => ColumnDefinition;
+	/**
+	 * Create a DATE column (stored as TEXT)
+	 */
+	date: (constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a DATETIME column (stored as TEXT)
+	 */
+	datetime: (constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a TIMESTAMP column (stored as INTEGER by default)
+	 */
+	timestamp: (constraints?: ColumnConstraints & {
+		asText?: boolean;
+	}) => ColumnDefinition;
+	/**
+	 * Create a TIME column (stored as TEXT)
+	 */
+	time: (constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a BOOLEAN column (stored as INTEGER)
+	 */
+	boolean: (constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a JSON column (stored as TEXT)
+	 */
+	json: (constraints?: ColumnConstraints & {
+		validateJson?: boolean;
+	}) => ColumnDefinition;
+	/**
+	 * Create a VARCHAR column with specified length
+	 */
+	varchar: (length: number, constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create a CHAR column with specified length
+	 */
+	char: (length: number, constraints?: ColumnConstraints) => ColumnDefinition;
+	/**
+	 * Create an auto-incrementing primary key column
+	 */
+	id: (constraints?: Omit<ColumnConstraints, "primaryKey" | "autoincrement" | "notNull">) => ColumnDefinition;
+	/**
+	 * Create a UUID column (stored as TEXT)
+	 */
+	uuid: (constraints?: ColumnConstraints & {
+		generateDefault?: boolean;
+	}) => ColumnDefinition;
+	/**
+	 * Create a created_at timestamp column
+	 */
+	createdAt: (constraints?: Omit<ColumnConstraints, "default" | "notNull"> & {
+		asText?: boolean;
+	}) => ColumnDefinition;
+	/**
+	 * Create an updated_at timestamp column
+	 */
+	updatedAt: (constraints?: Omit<ColumnConstraints, "default"> & {
+		asText?: boolean;
+	}) => ColumnDefinition;
+	/**
+	 * Create a foreign key reference column
+	 */
+	foreignKey: (refTable: string, refColumn?: string, constraints?: ColumnConstraints & {
+		onDelete?: ForeignKeyAction;
+		onUpdate?: ForeignKeyAction;
+		type?: SQLiteType;
+	}) => ColumnDefinition;
+	/**
+	 * Create an enum column (with CHECK constraint)
+	 */
+	enum: (values: string[], constraints?: ColumnConstraints) => ColumnDefinition;
+};
+/**
+ * SQL function helpers for use in defaults and expressions
+ */
+export declare const sql: {
+	raw: (expression: string) => DefaultExpression;
+	null: () => null;
+	true: () => number;
+	false: () => number;
+	DATE: (expr: string) => string;
+	TIME: (expr: string) => string;
+	DATETIME: (expr: string) => string;
+	JULIANDAY: (expr: string) => string;
+	STRFTIME: (format: string, expr: string) => string;
+	LENGTH: (expr: string) => string;
+	LOWER: (expr: string) => string;
+	UPPER: (expr: string) => string;
+	TRIM: (expr: string, chars?: string) => string;
+	LTRIM: (expr: string, chars?: string) => string;
+	RTRIM: (expr: string, chars?: string) => string;
+	SUBSTR: (expr: string, start: number, length?: number) => string;
+	SUBSTRING: (expr: string, start: number, length?: number) => string;
+	REPLACE: (expr: string, old: string, replacement: string) => string;
+	PRINTF: (format: string, ...args: string[]) => string;
+	ABS: (expr: string) => string;
+	ROUND: (expr: string, digits?: number) => string;
+	RANDOM: () => string;
+	MIN: (...exprs: string[]) => string;
+	MAX: (...exprs: string[]) => string;
+	CAST: (expr: string, type: string) => string;
+	TYPEOF: (expr: string) => string;
+	COALESCE: (...exprs: string[]) => string;
+	IFNULL: (expr: string, replacement: string) => string;
+	NULLIF: (expr1: string, expr2: string) => string;
+	IIF: (condition: string, trueValue: string, falseValue: string) => string;
+	COUNT: (expr?: string) => string;
+	SUM: (expr: string) => string;
+	AVG: (expr: string) => string;
+	TOTAL: (expr: string) => string;
+	GROUP_CONCAT: (expr: string, separator?: string) => string;
+	JSON: (expr: string) => string;
+	JSON_EXTRACT: (json: string, path: string) => string;
+	JSON_TYPE: (json: string, path?: string) => string;
+	JSON_VALID: (expr: string) => string;
+	JSON_ARRAY: (...values: string[]) => string;
+	JSON_OBJECT: (...pairs: string[]) => string;
+	now: () => DefaultExpression;
+	currentTime: () => DefaultExpression;
+	currentDate: () => DefaultExpression;
+	currentTimestamp: () => DefaultExpression;
+	unixTimestamp: () => DefaultExpression;
+};
+/**
+ * Column names type for SELECT operations
+ */
+export type ColumnNames<T> = [
 	"*"
-];
-export type WhereCondition<T> = Partial<Record<keyof T, string | number | boolean | null>>;
-export type RegexCondition<T> = Partial<Record<keyof T, string | RegExp>>;
+] | Array<keyof T>;
 /**
- * Result types for mutation operations
+ * WHERE condition object type
+ */
+export type WhereCondition<T> = Partial<T>;
+/**
+ * Regex condition object type
+ */
+export type RegexCondition<T> = Partial<Record<keyof T, RegExp | string>>;
+/**
+ * Insert result interface
  */
 export interface InsertResult {
-	/** The rowid of the last inserted row */
 	insertId: number;
-	/** Number of rows that were inserted */
 	changes: number;
 }
+/**
+ * Update result interface
+ */
 export interface UpdateResult {
-	/** Number of rows that were updated */
 	changes: number;
 }
+/**
+ * Delete result interface
+ */
 export interface DeleteResult {
-	/** Number of rows that were deleted */
 	changes: number;
 }
 /**
- * Options for INSERT operations
+ * Insert options interface
  */
 export interface InsertOptions {
-	/** Use INSERT OR IGNORE */
 	orIgnore?: boolean;
-	/** Use INSERT OR REPLACE */
 	orReplace?: boolean;
-	/** Use INSERT OR ABORT (default) */
 	orAbort?: boolean;
-	/** Use INSERT OR FAIL */
 	orFail?: boolean;
-	/** Use INSERT OR ROLLBACK */
 	orRollback?: boolean;
 }
 /**
- * Configuration for JSON columns that should be automatically serialized/deserialized
+ * JSON column configuration
  */
 export interface JsonColumnConfig<T> {
-	/** Columns that contain JSON data and should be auto-serialized/deserialized */
 	jsonColumns?: Array<keyof T>;
 }
 /**
@@ -60,7 +409,7 @@ export interface JsonColumnConfig<T> {
  * - DELETE: safe deletes with mandatory WHERE conditions
  * - WHERE: shared conditional logic across all operations
  */
-export declare class QueryBuilder<T extends Record<string, any>> {
+export declare class QueryBuilder<T extends Record<string, unknown>> {
 	private selectBuilder;
 	private insertBuilder;
 	private updateBuilder;
@@ -81,31 +430,31 @@ export declare class QueryBuilder<T extends Record<string, any>> {
 	/**
 	 * Add a raw SQL WHERE fragment with parameter binding.
 	 */
-	whereExpr(expr: string, params?: any[]): this;
+	whereExpr(expr: string, params?: SQLQueryBindings[]): this;
 	/**
 	 * Alias for whereExpr.
 	 */
-	whereRaw(expr: string, params?: any[]): this;
+	whereRaw(expr: string, params?: SQLQueryBindings[]): this;
 	/**
 	 * Add an IN clause with proper parameter binding.
 	 */
-	whereIn(column: keyof T, values: any[]): this;
+	whereIn(column: keyof T, values: SQLQueryBindings[]): this;
 	/**
 	 * Add a NOT IN clause with proper parameter binding.
 	 */
-	whereNotIn(column: keyof T, values: any[]): this;
+	whereNotIn(column: keyof T, values: SQLQueryBindings[]): this;
 	/**
 	 * Add a comparison operator condition.
 	 */
-	whereOp(column: keyof T, op: string, value: any): this;
+	whereOp(column: keyof T, op: string, value: SQLQueryBindings): this;
 	/**
 	 * Add a BETWEEN condition.
 	 */
-	whereBetween(column: keyof T, min: any, max: any): this;
+	whereBetween(column: keyof T, min: SQLQueryBindings, max: SQLQueryBindings): this;
 	/**
 	 * Add a NOT BETWEEN condition.
 	 */
-	whereNotBetween(column: keyof T, min: any, max: any): this;
+	whereNotBetween(column: keyof T, min: SQLQueryBindings, max: SQLQueryBindings): this;
 	/**
 	 * Add an IS NULL condition.
 	 */
@@ -236,7 +585,7 @@ export declare class QueryBuilder<T extends Record<string, any>> {
 	/**
 	 * Soft delete - mark rows as deleted instead of physically removing them.
 	 */
-	softDelete(deletedColumn?: keyof T, deletedValue?: any): DeleteResult;
+	softDelete(deletedColumn?: keyof T, deletedValue?: SQLQueryBindings): DeleteResult;
 	/**
 	 * Restore soft deleted rows.
 	 */
@@ -259,10 +608,16 @@ export declare class QueryBuilder<T extends Record<string, any>> {
 	deleteDuplicates(columns: Array<keyof T>): DeleteResult;
 }
 /**
- * TypedSQLite — tiny wrapper around bun:sqlite `Database`.
+ * TypedSQLite — comprehensive wrapper around bun:sqlite `Database`.
  *
- * This class centralizes common helpers like `table()` (returns a typed QueryBuilder)
- * and `createTable()` for creating tables easily.
+ * This class provides full type safety for SQLite operations with support for:
+ * - All SQLite data types and variations
+ * - Built-in SQL functions
+ * - Complex constraints and relationships
+ * - Generated columns
+ * - Table-level constraints
+ * - JSON column support
+ * - And much more...
  */
 export declare class DB {
 	private db;
@@ -275,117 +630,285 @@ export declare class DB {
 	constructor(path: string, options?: {
 		pragmas?: Array<[
 			string,
-			any
+			SQLQueryBindings
 		]>;
 		loadExtensions?: string[];
 	});
 	/**
 	 * Get a typed QueryBuilder for a given table name.
+	 * (Documentation remains the same as before...)
+	 */
+	table<T extends Record<string, unknown>>(tableName: string, jsonConfig?: JsonColumnConfig<T>): QueryBuilder<T>;
+	/**
+	 * Close the underlying SQLite database handle.
+	 */
+	close(): void;
+	/**
+	 * Create a table with comprehensive type safety and feature support.
 	 *
-	 * Example:
-	 * ```ts
-	 * interface User { id: number; name: string; email: string; }
-	 *
-	 * // SELECT operations
-	 * const users = db.table<User>("users")
-	 *   .select(["id", "name"])
-	 *   .where({ active: true })
-	 *   .orderBy("created_at")
-	 *   .desc()
-	 *   .limit(10)
-	 *   .all();
-	 *
-	 * // INSERT operations
-	 * const insertResult = db.table<User>("users")
-	 *   .insert({ name: "John", email: "john@example.com" });
+	 * Now supports all SQLite features:
 	 *
-	 * // UPDATE operations
-	 * const updateResult = db.table<User>("users")
-	 *   .where({ id: 1 })
-	 *   .update({ name: "Jane" });
+	 * **Basic Usage:**
+	 * ```ts
+	 * import { column, sql } from "./db";
 	 *
-	 * // DELETE operations
-	 * const deleteResult = db.table<User>("users")
-	 *   .where({ active: false })
-	 *   .delete();
+	 * db.createTable("users", {
+	 *   id: column.id(), // Auto-incrementing primary key
+	 *   email: column.varchar(255, { unique: true, notNull: true }),
+	 *   name: column.text({ notNull: true }),
+	 *   age: column.integer({ check: 'age >= 0 AND age <= 150' }),
+	 *   balance: column.numeric({ precision: 10, scale: 2, default: 0 }),
+	 *   is_active: column.boolean({ default: sql.true() }),
+	 *   metadata: column.json({ validateJson: true }),
+	 *   created_at: column.createdAt(),
+	 *   updated_at: column.updatedAt(),
+	 * });
 	 * ```
 	 *
-	 * For tables with JSON columns, you can specify which columns should be auto-serialized/deserialized:
+	 * **Advanced Features:**
 	 * ```ts
-	 * interface Config { id: number; settings: object; metadata: any[]; }
-	 *
-	 * const config = db.table<Config>("config", { jsonColumns: ["settings", "metadata"] })
-	 *   .select(["*"])
-	 *   .get(); // settings and metadata will be automatically parsed from JSON
+	 * db.createTable("orders", {
+	 *   id: column.id(),
+	 *   order_number: column.varchar(50, {
+	 *     unique: true,
+	 *     default: sql.raw("'ORD-' || strftime('%Y%m%d', 'now') || '-' || substr(hex(randomblob(4)), 1, 8)")
+	 *   }),
+	 *   customer_id: column.foreignKey('users', 'id', {
+	 *     onDelete: 'CASCADE',
+	 *     onUpdate: 'RESTRICT'
+	 *   }),
+	 *   status: column.enum(['pending', 'paid', 'shipped', 'delivered'], {
+	 *     default: 'pending'
+	 *   }),
+	 *   total: column.numeric({ precision: 10, scale: 2, notNull: true }),
+	 *   // Generated column
+	 *   display_total: {
+	 *     type: 'TEXT',
+	 *     generated: {
+	 *       expression: "printf('$%.2f', total)",
+	 *       stored: false // VIRTUAL column
+	 *     }
+	 *   },
+	 * }, {
+	 *   constraints: {
+	 *     check: ['total >= 0'],
+	 *     unique: [['customer_id', 'order_number']]
+	 *   }
+	 * });
 	 * ```
 	 *
-	 * `QueryBuilder` supports the following notable methods:
-	 *
-	 * **SELECT methods:**
-	 * - `select(columns: Array<keyof T> | ["*"])` — specify columns to select
-	 * - `where(conditions: Partial<Record<keyof T, string | number | boolean | null>>)` — simple equality/IS NULL checks
-	 * - `whereRgx(conditions: Partial<Record<keyof T, string | RegExp>>)` — regex conditions (applied client-side)
-	 * - `whereExpr(expr: string, params?: any[])` / `whereRaw(...)` — raw SQL fragments with parameter binding
-	 * - `whereIn(column: keyof T, values: any[])` — IN clause with parameter binding
-	 * - `whereOp(column: keyof T, op: string, value: any)` — comparison operators (=, !=, <, >, <=, >=, LIKE, GLOB, IS)
-	 * - `orderBy(column: keyof T)`, `asc()`, `desc()` — ordering
-	 * - `limit(n)`, `offset(n)` — pagination
-	 * - `all(): T[]`, `get(): T | null`, `first(): T | null`, `count(): number` — result execution
-	 *
-	 * **INSERT methods:**
-	 * - `insert(data: Partial<T> | Partial<T>[], options?: InsertOptions): InsertResult` — insert single/multiple rows
-	 * - `insertOrIgnore(data: Partial<T> | Partial<T>[]): InsertResult` — INSERT OR IGNORE
-	 * - `insertOrReplace(data: Partial<T> | Partial<T>[]): InsertResult` — INSERT OR REPLACE
-	 *
-	 * **UPDATE methods:**
-	 * - `update(data: Partial<T>): UpdateResult` — update rows (requires WHERE conditions)
+	 * **Date/Time Columns:**
+	 * ```ts
+	 * db.createTable("events", {
+	 *   id: column.id(),
+	 *   name: column.text({ notNull: true }),
+	 *   event_date: column.date({ notNull: true }),
+	 *   start_time: column.time(),
+	 *   created_at: column.timestamp({ default: sql.unixTimestamp() }),
+	 *   expires_at: column.datetime({
+	 *     default: sql.raw("datetime('now', '+1 year')")
+	 *   }),
+	 * });
+	 * ```
 	 *
-	 * **DELETE methods:**
-	 * - `delete(): DeleteResult` — delete rows (requires WHERE conditions)
+	 * **JSON and Advanced Types:**
+	 * ```ts
+	 * db.createTable("products", {
+	 *   id: column.uuid({ generateDefault: true }), // UUID primary key
+	 *   name: column.text({ notNull: true }),
+	 *   price: column.real({ check: 'price > 0' }),
+	 *   specifications: column.json({ validateJson: true }),
+	 *   tags: column.text(), // JSON array
+	 *   image_data: column.blob(),
+	 *   search_vector: {
+	 *     type: 'TEXT',
+	 *     generated: {
+	 *       expression: "lower(name || ' ' || coalesce(json_extract(specifications, '$.description'), ''))",
+	 *       stored: true // STORED for indexing
+	 *     }
+	 *   }
+	 * });
+	 * ```
 	 *
-	 * Notes:
-	 * - Regex conditions in `whereRgx` are applied client-side after SQL execution
-	 * - When regex conditions are present, ordering/limit/offset are also applied client-side
-	 * - UPDATE and DELETE operations require at least one WHERE condition for safety
-	 * - All mutations return result objects with `changes` count and `insertId` (for INSERT)
-	 * - JSON columns are automatically serialized on INSERT/UPDATE and deserialized on SELECT
+	 * @param tableName - Table name to create.
+	 * @param columns - Column definitions (string, legacy object, or type-safe schema).
+	 * @param options - Table options including constraints and metadata.
 	 *
-	 * @typeParam T - Row type for the table.
-	 * @param tableName - The table name to operate on.
-	 * @param jsonConfig - Optional configuration for JSON columns that should be auto-serialized/deserialized.
-	 * @returns QueryBuilder<T>
+	 * @throws {Error} If column definitions are invalid or constraints conflict.
 	 */
-	table<T extends Record<string, any>>(tableName: string, jsonConfig?: JsonColumnConfig<T>): QueryBuilder<T>;
+	createTable<_T extends Record<string, unknown>>(tableName: string, columns: string | Record<string, string> | TableSchema, options?: TableOptions): void;
 	/**
-	 * Close the underlying SQLite database handle.
-	 *
-	 * After calling `close()` the instance should not be used.
+	 * Create an index on a table
 	 */
-	close(): void;
+	createIndex(indexName: string, tableName: string, columns: string | string[], options?: {
+		unique?: boolean;
+		ifNotExists?: boolean;
+		where?: string;
+		partial?: string;
+	}): void;
 	/**
-	 * Create a table.
-	 *
-	 * Accepts either:
-	 * - `columns` as a single SQL column-definition string:
-	 *     "id INTEGER PRIMARY KEY, name TEXT NOT NULL"
-	 * - `columns` as object `{ colName: "SQL TYPE CONSTRAINTS", ... }`
-	 *
-	 * Options:
-	 * - `ifNotExists`: prepend `IF NOT EXISTS`
-	 * - `withoutRowId`: append `WITHOUT ROWID`
-	 *
-	 * The method will safely quote identifiers (double quotes).
-	 *
-	 * @param tableName - Table name to create.
-	 * @param columns - Column definitions (SQL string) or a map of column→definition.
-	 * @param options - Optional flags `{ ifNotExists?: boolean; withoutRowId?: boolean }`.
-	 *
-	 * @throws {Error} If column definitions are empty or invalid.
+	 * Drop a table
 	 */
-	createTable(tableName: string, columns: string | Record<string, string>, options?: {
-		ifNotExists?: boolean;
-		withoutRowId?: boolean;
+	dropTable(tableName: string, options?: {
+		ifExists?: boolean;
 	}): void;
+	/**
+	 * Drop an index
+	 */
+	dropIndex(indexName: string, options?: {
+		ifExists?: boolean;
+	}): void;
+	/**
+	 * Type guard to check if columns definition is a TableSchema
+	 */
+	private isTableSchema;
+	/**
+	 * Build SQL column definition from ColumnDefinition object
+	 */
+	private buildColumnSQL;
+	/**
+	 * Build table-level constraints
+	 */
+	private buildTableConstraints;
+	/**
+	 * Check if a string looks like a SQL function call
+	 */
+	private isSQLFunction;
+	/**
+	 * Store table comment as metadata (using a system table if needed)
+	 */
+	private setTableComment;
+	/**
+	 * Get table comment from metadata
+	 */
+	getTableComment(tableName: string): string | null;
+	/**
+	 * Execute a raw SQL statement
+	 */
+	exec(sql: string): void;
+	/**
+	 * Prepare a SQL statement for repeated execution
+	 */
+	prepare(sql: string): import("bun:sqlite").Statement<unknown, SQLQueryBindings[] | [
+		null
+	] | [
+		string
+	] | [
+		number
+	] | [
+		bigint
+	] | [
+		false
+	] | [
+		true
+	] | [
+		Uint8Array<ArrayBufferLike>
+	] | [
+		Uint8ClampedArray<ArrayBufferLike>
+	] | [
+		Uint16Array<ArrayBufferLike>
+	] | [
+		Uint32Array<ArrayBufferLike>
+	] | [
+		Int8Array<ArrayBufferLike>
+	] | [
+		Int16Array<ArrayBufferLike>
+	] | [
+		Int32Array<ArrayBufferLike>
+	] | [
+		BigUint64Array<ArrayBufferLike>
+	] | [
+		BigInt64Array<ArrayBufferLike>
+	] | [
+		Float32Array<ArrayBufferLike>
+	] | [
+		Float64Array<ArrayBufferLike>
+	] | [
+		Record<string, string | number | bigint | boolean | NodeJS.TypedArray<ArrayBufferLike> | null>
+	]>;
+	/**
+	 * Execute a transaction
+	 */
+	transaction<T>(fn: () => T): T;
+	/**
+	 * Begin a transaction manually
+	 */
+	begin(mode?: "DEFERRED" | "IMMEDIATE" | "EXCLUSIVE"): void;
+	/**
+	 * Commit a transaction
+	 */
+	commit(): void;
+	/**
+	 * Rollback a transaction
+	 */
+	rollback(): void;
+	/**
+	 * Create a savepoint
+	 */
+	savepoint(name: string): void;
+	/**
+	 * Release a savepoint
+	 */
+	releaseSavepoint(name: string): void;
+	/**
+	 * Rollback to a savepoint
+	 */
+	rollbackToSavepoint(name: string): void;
+	/**
+	 * Vacuum the database (reclaim space and optimize)
+	 */
+	vacuum(): void;
+	/**
+	 * Analyze the database (update statistics for query optimizer)
+	 */
+	analyze(tableName?: string): void;
+	/**
+	 * Check database integrity
+	 */
+	integrityCheck(): Array<{
+		integrity_check: string;
+	}>;
+	/**
+	 * Get database schema information
+	 */
+	getSchema(): Array<{
+		name: string;
+		type: string;
+		sql: string;
+	}>;
+	/**
+	 * Get table info (columns, types, constraints)
+	 */
+	getTableInfo(tableName: string): Array<{
+		cid: number;
+		name: string;
+		type: string;
+		notnull: number;
+		dflt_value: SQLQueryBindings;
+		pk: number;
+	}>;
+	/**
+	 * Get foreign key information for a table
+	 */
+	getForeignKeys(tableName: string): Array<{
+		id: number;
+		seq: number;
+		table: string;
+		from: string;
+		to: string;
+		on_update: string;
+		on_delete: string;
+		match: string;
+	}>;
+	/**
+	 * Get index information for a table
+	 */
+	getIndexes(tableName: string): Array<{
+		name: string;
+		unique: number;
+		origin: string;
+		partial: number;
+	}>;
 	/**
 	 * Set or get a PRAGMA value.
 	 *
@@ -393,7 +916,7 @@ export declare class DB {
 	 * @param value - Value to set (omit to get current value)
 	 * @returns Current value when getting, undefined when setting
 	 */
-	pragma(name: string, value?: any): any;
+	pragma(name: string, value?: SQLQueryBindings): SQLQueryBindings | undefined;
 	/**
 	 * Load a SQLite extension.
 	 *
@@ -402,11 +925,15 @@ export declare class DB {
 	loadExtension(path: string): void;
 	/**
 	 * Get direct access to the underlying SQLite database instance.
-	 * Use this for advanced operations not covered by the QueryBuilder.
+	 * Use this for advanced operations not covered by the wrapper.
 	 *
 	 * @returns The underlying Database instance
 	 */
 	getDb(): Database;
 }
 
+export {
+	DB as default,
+};
+
 export {};