@ignisia/sql 0.2.1 → 0.3.0

package/dist/cjs/index-2jl8MRfX.d.cts

@@ -0,0 +1,105 @@
+import { TransactionSQL } from 'bun';
+import { Column } from './column/index.cjs';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, h as QuerHooks, b as DatabaseDialect, i as DatabaseOptions, f as QueryBuilder, j as QueryRunHooks } from './index-CnQVnCEI.cjs';
+import { QueryHooksType } from './query/constants.cjs';
+import { Dialect } from './table/constants.cjs';
+import { AcceptedColumnTypes } from './column/constants.cjs';
+
+interface TableAlterationContract<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    createTable<TableName extends string, Columns extends Record<string, Column>, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, FinalColumns extends MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, NewTables extends Tables & {
+        [K in TableName]: Table<TableName, FinalColumns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+    }>(tableName: TableName, columns: Columns, options?: {
+        paranoid?: Paranoid;
+        timestamp?: Timestamp;
+    }): Promise<Database<DbDialect, NewTables, Definition>>;
+    renameTable<OldName extends (keyof Tables & string) | (string & {}), NewName extends string, NewTables extends Omit<Tables, OldName> & {
+        [K in NewName]: Tables[OldName];
+    }>(oldName: OldName, newName: NewName): Promise<Database<DbDialect, NewTables, Omit<Definition, 'tables'> & {
+        tables: NewTables;
+    }>>;
+    dropTable<TableName extends (keyof Tables & string) | (string & {})>(tableName: TableName): Promise<Database<DbDialect, Omit<Tables, TableName>, Definition>>;
+}
+interface ColumnAlterationContract<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    addColumn<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Tables[TableName]['columns'] & {
+            [K in ColName]: Column;
+        }>;
+    }>(tableName: TableName, columnName: ColName, column: Column): Promise<Database<DbDialect, NewTables, Definition>>;
+    renameColumn<TableName extends (keyof Tables & string) | (string & {}), OldName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], OldName> & {
+            [K in NewName]: Tables[TableName]['columns'][OldName];
+        }>;
+    }>(tableName: TableName, oldName: OldName, newName: NewName): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumn<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName>>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    alterColumnType<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), Type extends Omit<AcceptedColumnTypes, typeof AcceptedColumnTypes.ENUM>, NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Tables[TableName]['columns'][ColName] & {
+                type: Type;
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName, newType: Type): Promise<Database<DbDialect, NewTables, Definition>>;
+    setColumnDefault<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), DefaultValue extends string | number | boolean | null, NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                    default: DefaultValue;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName, value: DefaultValue): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumnDefault<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                    default: undefined;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    setColumnNotNull<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'> & {
+                    notNull: true;
+                };
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+    dropColumnNotNull<TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+        [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+            [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+                definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'>;
+            };
+        }>;
+    }>(tableName: TableName, columnName: ColName): Promise<Database<DbDialect, NewTables, Definition>>;
+}
+
+declare class Database<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
+    readonly hooks: Partial<QuerHooks>;
+    readonly dialect: DbDialect;
+    readonly defintion: Definition;
+    readonly tables: Tables;
+    readonly client: DatabaseDialect;
+    createTable: TableAlterationContract<DbDialect, Tables, Definition>['createTable'];
+    renameTable: TableAlterationContract<DbDialect, Tables, Definition>['renameTable'];
+    dropTable: TableAlterationContract<DbDialect, Tables, Definition>['dropTable'];
+    addColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['addColumn'];
+    renameColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['renameColumn'];
+    dropColumn: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumn'];
+    alterColumnType: ColumnAlterationContract<DbDialect, Tables, Definition>['alterColumnType'];
+    setColumnDefault: ColumnAlterationContract<DbDialect, Tables, Definition>['setColumnDefault'];
+    dropColumnDefault: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnDefault'];
+    setColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['setColumnNotNull'];
+    dropColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnNotNull'];
+    protected constructor(options: DatabaseOptions<DbDialect, Tables>);
+    private createClient;
+    table<TableName extends keyof Tables & string, Table extends Tables[TableName]>(tableName: TableName): QueryBuilder<TableName, Table>;
+    addHook(type: QueryHooksType, fn: QueryRunHooks): this;
+    removeHook(type: QueryHooksType, fn: QueryRunHooks): this;
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<unknown>;
+    static define<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>>(options: DatabaseOptions<DbDialect, Tables>): Database<DbDialect, Tables, DatabaseDefinition<DbDialect>>;
+}
+
+export { type ColumnAlterationContract as C, Database as D, type TableAlterationContract as T };

package/dist/cjs/index-CnQVnCEI.d.cts

@@ -0,0 +1,392 @@
+import { Column } from './column/index.cjs';
+import { AcceptedColumnTypes } from './column/constants.cjs';
+import { UnionToIntersection } from './types.cjs';
+import { QueryType, OrderBy, AggregationFunction, QueryHooksType, AcceptedOperator, ConditionClause, LogicalOperator } from './query/constants.cjs';
+import { TransactionSQL } from 'bun';
+import { Dialect } from './table/constants.cjs';
+
+type ColumnSelector<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = `${Alias}."${keyof TableRef['columns'] & string}"` | `${Alias}.*` | {
+    [A in keyof JoinedTables]: `${A & string}."${keyof JoinedTables[A]['columns'] & string}"` | `${A & string}.*`;
+}[keyof JoinedTables];
+type StrictColumnSelector<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = `${Alias}."${keyof TableRef['columns'] & string}"` | {
+    [A in keyof JoinedTables]: `${A & string}."${keyof JoinedTables[A]['columns'] & string}"`;
+}[keyof JoinedTables];
+type WhereValue<T extends Column> = {
+    [K in AcceptedOperator]: K extends typeof AcceptedOperator.BETWEEN | typeof AcceptedOperator.NOT_BETWEEN ? [T['_output'], T['_output']] : K extends typeof AcceptedOperator.IN | typeof AcceptedOperator.NOT_IN ? T['_output'][] : K extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL ? never : T['_output'];
+};
+type AcceptedOrderBy<Columns extends string> = {
+    column: Columns;
+    direction: OrderBy;
+};
+type InsertValuesParser<Columns extends Record<string, Column>> = {
+    [ColName in keyof Columns]: {
+        output: Columns[ColName]['_output'];
+        required: Columns[ColName]['definition'] extends {
+            type: infer Type;
+        } ? Type extends typeof AcceptedColumnTypes.SERIAL ? false : Columns[ColName]['definition'] extends {
+            notNull: true;
+        } ? true : Columns[ColName]['definition'] extends {
+            autoIncrement: true;
+        } ? false : Columns[ColName]['definition'] extends {
+            default: unknown;
+        } ? false : true : false;
+    };
+};
+type InsertValuesParserRequired<Parsed extends InsertValuesParser<Record<string, Column>>> = {
+    [ColName in keyof Parsed as Parsed[ColName]['required'] extends true ? ColName : never]: Parsed[ColName]['output'];
+};
+type InsertValuesParserOptional<Parsed extends InsertValuesParser<Record<string, Column>>> = {
+    [ColName in keyof Parsed as Parsed[ColName]['required'] extends false ? ColName : never]?: Parsed[ColName]['output'];
+};
+type AcceptedInsertValues<Columns extends Record<string, Column>, Parsed extends InsertValuesParser<Columns> = InsertValuesParser<Columns>, Required extends InsertValuesParserRequired<Parsed> = InsertValuesParserRequired<Parsed>, Optional extends InsertValuesParserOptional<Parsed> = InsertValuesParserOptional<Parsed>> = Array<Required & Optional>;
+type AcceptedUpdateValues<Columns extends Record<string, Column>> = {
+    [ColName in keyof Columns]?: Columns[ColName]['_output'];
+};
+type RawColumn<AllowedColumn extends string> = AllowedColumn;
+type AliasedColumn<Allowed extends string, Alias extends string = string> = {
+    column: Allowed;
+    as: Alias;
+};
+type SelectableColumn<Allowed extends string> = RawColumn<Allowed> | AliasedColumn<Allowed>;
+type AggregateColumn<Allowed extends string, Fn extends AggregationFunction = AggregationFunction, Alias extends string = string> = {
+    column: Allowed;
+    as?: Alias | Fn;
+    fn: AggregationFunction;
+};
+interface QueryDefinition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>> = NonNullable<unknown>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables> = ColumnSelector<Alias, TableRef, JoinedTables>> {
+    queryType: QueryType | null;
+    select: SelectableColumn<AllowedColumn>[] | null;
+    where: string[] | null;
+    having: string[] | null;
+    params: unknown[] | null;
+    limit: number | null;
+    offset: number | null;
+    groupBy: AllowedColumn[] | null;
+    insertValues: AcceptedInsertValues<TableRef['columns']> | null;
+    updateValues: AcceptedUpdateValues<TableRef['columns']> | null;
+    orderBy: AcceptedOrderBy<AllowedColumn>[] | null;
+    aggregates: AggregateColumn<AllowedColumn>[] | null;
+    distinct: boolean | null;
+    joins: string[] | null;
+    baseAlias: Alias | null;
+    withDeleted: boolean | null;
+    joinedTables: JoinedTables | null;
+}
+type InsertUpdateDeleteQueryOutput<TableRef extends Table<string, Record<string, Column>>> = {
+    [K in keyof TableRef['columns']]: TableRef['columns'][K]['_output'];
+};
+type InferAliasedColumn<Current extends AliasedColumn<string, string>, Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = Current extends {
+    column: `${infer TableAlias}."${infer ColName}"`;
+    as: `${infer ColAlias}`;
+} ? TableAlias extends keyof JoinedTables ? {
+    [T in TableAlias]: {
+        [K in ColAlias]: JoinedTables[T]['columns'][ColName]['_output'];
+    };
+} : TableAlias extends Alias | TableRef['name'] ? {
+    [K in ColName as ColAlias]: TableRef['columns'][K]['_output'];
+} : NonNullable<unknown> : NonNullable<unknown>;
+type InferRawColumn<Current extends string, Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = Current extends `${infer TableAlias}."${infer ColName}"` ? TableAlias extends keyof JoinedTables ? {
+    [T in TableAlias]: {
+        [K in ColName]: JoinedTables[T]['columns'][K]['_output'];
+    };
+} : TableAlias extends Alias | TableRef['name'] ? {
+    [K in ColName]: TableRef['columns'][K]['_output'];
+} : NonNullable<unknown> : Current extends `${infer TableAlias}.${infer ColName}` ? ColName extends '*' ? TableAlias extends keyof JoinedTables ? {
+    [T in TableAlias]: {
+        [K in keyof JoinedTables[T]['columns']]: JoinedTables[T]['columns'][K]['_output'];
+    };
+} : TableAlias extends Alias | TableRef['name'] ? {
+    [K in keyof TableRef['columns']]: TableRef['columns'][K]['_output'];
+} : NonNullable<unknown> : NonNullable<unknown> : NonNullable<unknown>;
+type InferSelectQueryOutput<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>> = Definition extends {
+    select: infer Select;
+} ? Select extends Array<SelectableColumn<AllowedColumn>> ? UnionToIntersection<Select[number] extends infer Col ? Col extends RawColumn<AllowedColumn> ? InferRawColumn<Col, Alias, TableRef, JoinedTables> : Col extends AliasedColumn<AllowedColumn> ? InferAliasedColumn<Col, Alias, TableRef, JoinedTables> : NonNullable<unknown> : NonNullable<unknown>> : NonNullable<unknown> : NonNullable<unknown>;
+type InferAggregateColumn<Current extends AggregateColumn<string>, Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = Current extends {
+    column: `${infer TableAlias}."${infer ColName}"`;
+    as: `${infer ColAlias}`;
+    fn?: AggregationFunction;
+} ? TableAlias extends keyof JoinedTables ? {
+    [T in TableAlias]: {
+        [K in ColAlias]: JoinedTables[T]['columns'][ColName]['_output'] | number;
+    };
+} : TableAlias extends Alias | TableRef['name'] ? {
+    [K in ColName as ColAlias]: TableRef['columns'][K]['_output'] | number;
+} : NonNullable<unknown> : NonNullable<unknown>;
+type InferAggregateQueryOutput<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>> = Definition extends {
+    aggregates: infer Aggregates;
+} ? Aggregates extends Array<AggregateColumn<AllowedColumn>> ? UnionToIntersection<Aggregates[number] extends infer Col ? Col extends RawColumn<AllowedColumn> ? InferRawColumn<Col, Alias, TableRef, JoinedTables> : Col extends AliasedColumn<AllowedColumn> ? InferAliasedColumn<Col, Alias, TableRef, JoinedTables> : Col extends AggregateColumn<AllowedColumn> ? InferAggregateColumn<Col, Alias, TableRef, JoinedTables> : NonNullable<unknown> : NonNullable<unknown>> : NonNullable<unknown> : NonNullable<unknown>;
+type SelectQueryOutput<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>> = InferSelectQueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn> & InferAggregateQueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn>;
+type QueryOutput<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>> = Definition extends {
+    queryType: infer Type;
+} ? Type extends null ? never : Type extends typeof QueryType.INSERT | typeof QueryType.UPDATE | typeof QueryType.DELETE ? InsertUpdateDeleteQueryOutput<TableRef>[] : Type extends typeof QueryType.SELECT ? SelectQueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn>[] : never : never;
+interface QueryRunHooksOptions {
+    query: string;
+    hook: QueryHooksType;
+    params: unknown[] | null | undefined;
+    type: QueryType;
+}
+interface QueryRunHooks {
+    (options: QueryRunHooksOptions): void;
+}
+interface QuerHooks {
+    after: Set<QueryRunHooks>;
+    before: Set<QueryRunHooks>;
+}
+
+type SqlConfigMapping = {
+    [Dialect.POSTGRES]: PostgresConfig;
+    [Dialect.MYSQL]: MysqlConfig;
+    [Dialect.SQLITE]: SqliteConfig;
+};
+interface SqliteConfig {
+    filename: ':memory:' | (string & {});
+}
+interface SqlConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}
+interface PostgresConfig extends SqlConfig {
+}
+interface MysqlConfig extends SqlConfig {
+}
+interface DatabaseOptions<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
+    dialect: DbDialect;
+    config: SqlConfigMapping[DbDialect];
+    tables?: Tables;
+}
+interface DatabaseExecOptions {
+    sql: string;
+    params?: unknown[] | null | undefined;
+    tx?: TransactionSQL | null;
+}
+interface DatabaseDefinition<DbDialect extends Dialect> extends Omit<DatabaseOptions<DbDialect, any>, 'tables'> {
+}
+interface DatabaseDialect {
+    status: 'connecting' | 'connected' | 'disconnected';
+    connect(): Promise<this>;
+    disconnect(): Promise<this>;
+    exec<T>(options: DatabaseExecOptions): Promise<T>;
+    /**
+     * Begins a transaction
+     */
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<T>;
+    /**
+     * Begins a distributed transaction
+     */
+    distributed<T extends string, U, V extends (tx: TransactionSQL) => Promise<U>>(name: T, fn: V): Promise<U>;
+}
+
+declare const createdAt: Column<AcceptedColumnTypes, number | readonly string[], {
+    type: "DATETIME";
+}, Date, Date, {
+    default: "CURRENT_TIMESTAMP";
+}>;
+declare const updatedAt: Column<AcceptedColumnTypes, number | readonly string[], {
+    type: "DATETIME";
+}, Date, Date, {}>;
+declare const deletedAt: Column<AcceptedColumnTypes, number | readonly string[], {
+    type: "DATETIME";
+}, Date, Date, {}>;
+declare function defineColumns<TableName extends string, Columns extends Record<string, Column>, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, FinalColumns extends MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>>(options: TableOptions<TableName, Columns, Dialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): FinalColumns;
+
+interface TimestampOptions<CreatedAt extends string | boolean, UpdatedAt extends string | boolean> {
+    createdAt?: CreatedAt;
+    updatedAt?: UpdatedAt;
+}
+interface TableOptions<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> {
+    dialect?: DbDialect;
+    name: TableName;
+    columns: Columns;
+    paranoid?: Paranoid;
+    timestamp?: Timestamp;
+}
+type MergeTimestampParanoid<Columns extends Record<string, Column>, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> = Columns & (Timestamp extends true ? {
+    createdAt: typeof createdAt;
+    updatedAt: typeof updatedAt;
+} : Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> ? (Timestamp['createdAt'] extends CreatedAt ? Timestamp['createdAt'] extends true ? {
+    createdAt: typeof createdAt;
+} : Timestamp['createdAt'] extends string ? {
+    [K in Timestamp['createdAt']]: typeof createdAt;
+} : NonNullable<unknown> : {
+    createdAt: typeof createdAt;
+}) & (Timestamp['updatedAt'] extends UpdatedAt ? Timestamp['updatedAt'] extends true ? {
+    updatedAt: typeof updatedAt;
+} : Timestamp['updatedAt'] extends string ? {
+    [K in Timestamp['updatedAt']]: typeof updatedAt;
+} : NonNullable<unknown> : {
+    updatedAt: typeof updatedAt;
+}) : NonNullable<unknown>) & (Paranoid extends true ? {
+    deletedAt: typeof deletedAt;
+} : Paranoid extends string ? {
+    [K in Paranoid]: typeof deletedAt;
+} : NonNullable<unknown>);
+type TableOutput<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, TableRef extends Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid> = Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>> = {
+    [K in keyof TableRef['columns'] & string]: TableRef['columns'][K]['_output'];
+};
+interface ExecOptions {
+    tx?: TransactionSQL | null;
+    db?: DatabaseDialect | null;
+}
+
+declare class Table<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect = Dialect, CreatedAt extends string | boolean = string | boolean, UpdatedAt extends string | boolean = string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean = TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean = string | boolean> {
+    client: DatabaseDialect | null;
+    private _dialect;
+    readonly name: TableName;
+    readonly columns: Columns;
+    readonly timestamp: Timestamp | null;
+    readonly paranoid: Paranoid | null;
+    readonly _output: TableOutput<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+    protected constructor(options: TableOptions<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>);
+    infer(): this['_output'];
+    static define<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean>(options: TableOptions<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): Table<TableName, MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, DbDialect, string | boolean, string | boolean, Timestamp, Paranoid>;
+    setColumnDialect<DbDialect extends Dialect>(dialect: DbDialect): void;
+    get dialect(): DbDialect | null;
+    setDialect<DbDialect extends Dialect>(dialect: DbDialect): Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+    create(options?: ExecOptions): Promise<this>;
+    drop(options?: ExecOptions): Promise<this>;
+    query(): QueryBuilder<this["name"], this, {}, {}, ColumnSelector<this["name"], this, {}>, `${this["name"]}."${keyof this["columns"] & string}"`>;
+}
+
+declare function alias<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, NewAlias extends string>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, "baseAlias"> & {
+    baseAlias: NewAlias;
+}>;
+declare function clone<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
+declare function rawCol<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn>(column: ColName): ColName;
+declare function col<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(column: ColName, alias: ColAlias): {
+    readonly column: ColName;
+    readonly as: ColAlias;
+};
+declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn>(fn: Aggregate, column: ColName): {
+    column: ColName;
+    as: Lowercase<Aggregate>;
+    fn: Aggregate;
+};
+declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(fn: Aggregate, column: ColName, alias: ColAlias): {
+    column: ColName;
+    as: ColAlias;
+    fn: Aggregate;
+};
+
+declare function addRawCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Clause extends ConditionClause, Logical extends LogicalOperator, ValidClause extends Lowercase<Clause>>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, clause: Clause, column: (c: typeof rawCol) => string, logical: Logical, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
+declare function rawWhere<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
+declare function rawOr<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
+declare function rawHaving<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
+declare function addCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Clause extends ConditionClause, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator], Logical extends LogicalOperator, ValidClause extends Lowercase<Clause>>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, clause: Clause, column: ColName, operator: Operator, value: Value, logical: Logical): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, ValidClause> & { [Key in ValidClause]: string[]; }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+declare function where<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+declare function or<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+declare function having<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+
+interface QueryTransformerContract<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>> {
+    toQuery(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, dialect?: Dialect | null): {
+        query: string;
+        params: unknown[] | null | undefined;
+    };
+    toString(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+    exec<This extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends This['_output'] = This['_output']>(this: This, tx?: TransactionSQL | null): Promise<Output>;
+    clone(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): typeof this;
+    alias<NewAlias extends string>(alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, 'baseAlias'> & {
+        baseAlias: NewAlias;
+    }>;
+}
+interface QueryConditionContract<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>> {
+    rawWhere(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+    rawOr(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
+    rawHaving(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
+    where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+    where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+    or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
+    or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
+    having<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
+}
+
+declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>> = NonNullable<unknown>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>> = NonNullable<unknown>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables> = ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables> = StrictColumnSelector<Alias, TableRef, JoinedTables>> {
+    readonly hooks: Partial<QuerHooks>;
+    readonly table: TableRef;
+    readonly definition: Definition;
+    readonly _output: QueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn>;
+    alias: QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['alias'];
+    clone: QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['clone'];
+    toQuery: QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['toQuery'];
+    toString: QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['toString'];
+    exec: QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['exec'];
+    rawWhere: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['rawWhere'];
+    rawAnd: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['rawWhere'];
+    rawOr: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['rawOr'];
+    rawHaving: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['rawHaving'];
+    where: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['where'];
+    and: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['where'];
+    or: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['or'];
+    having: QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>['having'];
+    constructor(table: TableRef);
+    leftJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`>(joinTable: JoinTable, alias: JoinAlias, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>;
+    rightJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`>(joinTable: JoinTable, alias: JoinAlias, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>;
+    innerJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`>(joinTable: JoinTable, alias: JoinAlias, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>;
+    naturalJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`>(joinTable: JoinTable, alias: JoinAlias, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>;
+    distinct(): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        distinct: true;
+    }>;
+    aggregate<Aggregates extends Array<(c: typeof aggregateCol) => AggregateColumn<AllowedColumn>>>(...aggregates: Aggregates): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "aggregates"> & {
+        aggregates: { [K in keyof Aggregates]: Aggregates[K] extends (col: never) => infer R ? R : Aggregates[K]; };
+    }>;
+    groupBy<Groupable extends NonNullable<Definition['select']>, Columns extends Groupable extends readonly (infer Col)[] ? Col extends RawColumn<StrictAllowedColumn> ? Col[] : Col extends AliasedColumn<StrictAllowedColumn, infer Alias> ? Alias[] : StrictAllowedColumn[] : StrictAllowedColumn[]>(...columns: Columns): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        groupBy: Columns;
+    }>;
+    limit<Limit extends number | null>(limit: Limit): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        limit: Limit;
+    }>;
+    offset<Offset extends number | null>(offset: Offset): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        offset: Offset;
+    }>;
+    orderBy<OrderBy extends AcceptedOrderBy<StrictAllowedColumn>>(...orderBy: OrderBy[]): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        orderBy: OrderBy;
+    }>;
+    withDeleted(): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
+        withDeleted: true;
+    }>;
+    select<Base extends Definition['baseAlias'] extends string ? Definition['baseAlias'] : TableRef['name'], Columns extends TableRef['columns']>(): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, 'queryType' | 'select'> & {
+        queryType: typeof QueryType.SELECT;
+        select: Array<`${Base}."${keyof Columns & string}"`>;
+    }>;
+    select<Columns extends Array<RawColumn<AllowedColumn> | ((c: typeof col) => AliasedColumn<AllowedColumn, string>)>>(...columns: Columns): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, 'queryType' | 'select'> & {
+        queryType: typeof QueryType.SELECT;
+        select: {
+            [K in keyof Columns]: Columns[K] extends (col: never) => infer R ? R : Columns[K];
+        };
+    }>;
+    insert(...values: AcceptedInsertValues<TableRef['columns']>): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "queryType" | "insertValues"> & {
+        queryType: typeof QueryType.INSERT;
+        insertValues: AcceptedInsertValues<TableRef["columns"]>;
+    }>;
+    update<Values extends AcceptedUpdateValues<TableRef['columns']>>(values: Values): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "queryType" | "updateValues"> & {
+        queryType: typeof QueryType.UPDATE;
+        updateValues: Values;
+    }>;
+    delete(): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "queryType" | "updateValues"> & {
+        queryType: typeof QueryType.UPDATE;
+        updateValues: AcceptedUpdateValues<TableRef["columns"]>;
+    }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+    infer(): this['_output'];
+}
+
+export { type AliasedColumn as A, clone as B, type ColumnSelector as C, type DatabaseDefinition as D, type ExecOptions as E, rawCol as F, col as G, aggregateCol as H, addRawCondition as I, rawWhere as J, rawOr as K, rawHaving as L, type MergeTimestampParanoid as M, addCondition as N, where as O, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqlConfigMapping as S, Table as T, or as U, having as V, type WhereValue as W, type QueryTransformerContract as X, type QueryConditionContract as Y, type TimestampOptions as a, type DatabaseDialect as b, type DatabaseExecOptions as c, type SqliteConfig as d, type StrictColumnSelector as e, QueryBuilder as f, type SelectableColumn as g, type QuerHooks as h, type DatabaseOptions as i, type QueryRunHooks as j, type AcceptedOrderBy as k, type AcceptedInsertValues as l, type AcceptedUpdateValues as m, type AggregateColumn as n, type SelectQueryOutput as o, type QueryOutput as p, type QueryRunHooksOptions as q, type SqlConfig as r, type MysqlConfig as s, createdAt as t, updatedAt as u, deletedAt as v, defineColumns as w, type TableOptions as x, type TableOutput as y, alias as z };

package/dist/cjs/index.d.cts

@@ -0,0 +1,11 @@
+export { Column } from './column/index.cjs';
+export { D as Database } from './index-2jl8MRfX.cjs';
+export { Migration } from './migration/index.cjs';
+export { f as QueryBuilder, T as Table } from './index-CnQVnCEI.cjs';
+import './table/constants.cjs';
+import './column/constants.cjs';
+import './column/types.cjs';
+import 'bun';
+import './query/constants.cjs';
+import './migration/type.cjs';
+import './types.cjs';

package/dist/cjs/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var column = require('./column');
+var database = require('./database');
+var migration = require('./migration');
+var query = require('./query');
+var table = require('./table');
+
+
+
+Object.defineProperty(exports, "Column", {
+  enumerable: true,
+  get: function () { return column.Column; }
+});
+Object.defineProperty(exports, "Database", {
+  enumerable: true,
+  get: function () { return database.Database; }
+});
+Object.defineProperty(exports, "Migration", {
+  enumerable: true,
+  get: function () { return migration.Migration; }
+});
+Object.defineProperty(exports, "QueryBuilder", {
+  enumerable: true,
+  get: function () { return query.QueryBuilder; }
+});
+Object.defineProperty(exports, "Table", {
+  enumerable: true,
+  get: function () { return table.Table; }
+});

package/dist/cjs/migration/index.d.cts

@@ -0,0 +1,31 @@
+import { Column } from '../column/index.cjs';
+import { D as Database } from '../index-2jl8MRfX.cjs';
+import { T as Table } from '../index-CnQVnCEI.cjs';
+import { Dialect } from '../table/constants.cjs';
+import { MigrationOptions, MigrationFn } from './type.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../types.cjs';
+
+declare class Migration<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
+    readonly db: Database<DbDialect, Tables>;
+    protected _up: (() => Promise<void>) | null;
+    protected _down: (() => Promise<void>) | null;
+    protected constructor(options: MigrationOptions<DbDialect, Tables>);
+    get up(): (() => Promise<void>) | null;
+    get down(): (() => Promise<void>) | null;
+    static setUp<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Migrator extends Migration<DbDialect, Tables>, Fn extends MigrationFn<DbDialect, Tables>>(migrator: Migrator, fn: Fn): Migrator;
+    static setDown<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Migrator extends Migration<DbDialect, Tables>, Fn extends MigrationFn<DbDialect, Tables>>(migrator: Migrator, fn: Fn): Migrator;
+    static define<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>>(db: Database<DbDialect, Tables>, options?: {
+        up?: MigrationFn<DbDialect, Tables>;
+        down?: MigrationFn<DbDialect, Tables>;
+    }): {
+        migration: Migration<DbDialect, Tables>;
+        setUp<Fn extends MigrationFn<DbDialect, Tables>>(fn: Fn): Migration<DbDialect, Tables>;
+        setDown<Fn extends MigrationFn<DbDialect, Tables>>(fn: Fn): Migration<DbDialect, Tables>;
+    };
+}
+
+export { Migration };

package/dist/{migration → cjs/migration}/index.js

@@ -1,3 +1,5 @@
+'use strict';
+
 class Migration {
   db;
   _up;
@@ -45,4 +47,4 @@ class Migration {
   }
 }
 
-export { Migration };
+exports.Migration = Migration;