typhex 0.1.0-alpha.0

package/etc/typhex.api.md

@@ -0,0 +1,774 @@
+## API Report File for "typhex"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import pg from 'pg';
+
+// @public
+export interface AnyEntityClass {
+    query<C extends AnyEntityClass>(this: C, executor?: QueryExecutor): QueryBuilder<C, EntityInstance<C>>;
+    table: TableDef<Record<string, string>, RelationsMap>;
+    transaction<T>(fn: (trx: Trx) => Promise<T>): Promise<T>;
+}
+
+// @public (undocumented)
+export function appliedMigrations(driver: Driver): Promise<MigrationRecord[]>;
+
+// @public
+export function avg(_field: number): number;
+
+// @public
+export type ColumnChange = {
+    kind: "type";
+    from: string;
+    to: string;
+} | {
+    kind: "not_null" | "nullable";
+    from: boolean;
+    to: boolean;
+} | {
+    kind: "default";
+    from: string | null;
+    to: string | null;
+} | {
+    kind: "primary_key";
+    from: boolean;
+    to: boolean;
+};
+
+// @public
+export type ColumnDef = string | {
+    [K in DialectName]?: string;
+};
+
+// @public
+export interface CompiledCteBody {
+    // (undocumented)
+    bodyParams: unknown[];
+    // (undocumented)
+    bodySql: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    recursive?: boolean;
+}
+
+// @public
+export interface Connection<TDialect extends DialectInfo = DialectInfo> {
+    readonly dialect: TDialect;
+    execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+    release(): Promise<void>;
+}
+
+// @public
+export function count(_field?: unknown): number;
+
+// @public
+export function createDriver(options: CreateDriverOptions): Driver;
+
+// @public
+export type CreateDriverOptions = ({
+    dialect: "sqlite";
+} & SqliteDriverOptions) | ({
+    dialect: "postgres";
+} & PostgresDriverOptions);
+
+// @public
+export function createPostgresDriver(options: PostgresDriverOptions): Driver;
+
+// @public
+export function createSqliteDriver(options: SqliteDriverOptions): Driver;
+
+// @public
+export class Db implements QueryExecutor {
+    constructor(options: DbOptions | Driver);
+    appliedMigrations(): Promise<MigrationRecord[]>;
+    beginTrx(options?: TransactionOptions): Promise<Trx>;
+    close(): Promise<void>;
+    get dialect(): DialectInfo;
+    downMigration(name: string, dir?: string): Promise<void>;
+    get driver(): Driver;
+    dryRunMigrations(dir?: string): Promise<{
+        applied: MigrationRecord[];
+        pending: PendingMigration[];
+        skipped: string[];
+    }>;
+    static fromConfig(options?: {
+        configPath?: string;
+        cwd?: string;
+    }): Promise<Db>;
+    generateMigrations(dir?: string): Promise<MigrationFile[]>;
+    migrate(): Promise<void>;
+    migrationStatus(dir?: string): Promise<{
+        applied: MigrationRecord[];
+        pending: string[];
+    }>;
+    pendingMigrations(dir?: string): Promise<PendingMigration[]>;
+    query(sql: string, params?: unknown[]): Promise<unknown[]>;
+    run(sql: string, params?: unknown[]): Promise<{
+        lastID?: number;
+        changes: number;
+    }>;
+    runMigrations(dir?: string): Promise<MigrationResult>;
+    transaction<T>(fn: (trx: Trx) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    upMigration(name: string, dir?: string): Promise<void>;
+    validate(): Promise<void>;
+}
+
+// @public (undocumented)
+export interface DbColumnInfo {
+    // (undocumented)
+    dflt_value: string | null;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    notnull: number;
+    // (undocumented)
+    pk: number;
+    // (undocumented)
+    type: string;
+}
+
+// @public
+export type DbOptions = {
+    driver: Driver;
+    migrationsFolder?: string;
+} | {
+    dialect: DialectName;
+    database?: string;
+    url?: string;
+    migrationsFolder?: string;
+};
+
+// @public
+export interface DialectInfo {
+    // (undocumented)
+    readonly name: DialectName;
+}
+
+// @public
+export type DialectName = "sqlite" | "postgres";
+
+// @public (undocumented)
+export type DiffAction = {
+    kind: "add_table";
+    table: string;
+    schema: Record<string, ColumnDef>;
+} | {
+    kind: "drop_table";
+    table: string;
+    columnInfos: DbColumnInfo[];
+} | {
+    kind: "add_column";
+    table: string;
+    column: string;
+    definition: ColumnDef;
+} | {
+    kind: "drop_column";
+    table: string;
+    column: string;
+    columnInfo: DbColumnInfo;
+} | {
+    kind: "alter_column";
+    table: string;
+    column: string;
+    oldDef: string;
+    newDef: ColumnDef;
+    columnInfo: DbColumnInfo;
+    changes: ColumnChange[];
+};
+
+// @public
+export function diffSchema(driver: Driver, entities: readonly RegisteredEntity[]): Promise<DiffAction[]>;
+
+// @public
+export function distinct<T>(_field: T): T;
+
+// @public (undocumented)
+export function downMigration(driver: Driver, dir: string, name: string): Promise<void>;
+
+// @public
+export interface Driver<TDialect extends DialectInfo = DialectInfo> {
+    close(): Promise<void>;
+    connect(): Promise<Connection<TDialect>>;
+    createTrx(conn: Connection<TDialect>, options?: TransactionOptions): Trx;
+    readonly dialect: TDialect;
+    execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+}
+
+// @public (undocumented)
+export function dryRunMigrations(driver: Driver, dir: string): Promise<{
+    applied: MigrationRecord[];
+    pending: PendingMigration[];
+    skipped: string[];
+}>;
+
+// @public
+export function Entity<TTable extends string, const TSchema extends Record<string, string>, const TRels extends RelationsMap = {}>(tableName: TTable, schema: TSchema, relations?: TRels): EntityClass<TTable, TSchema, TRels>;
+
+// @public
+export interface EntityBase {
+    _dirty: ReadonlySet<string>;
+    _isNew: boolean;
+    query(trx?: Trx): SingleRowQueryBuilder<this>;
+}
+
+// @public
+export interface EntityClass<_TTable extends string, TSchema extends Record<string, string>, TRels extends RelationsMap = {}> extends AnyEntityClass {
+    new (data?: Partial<InferTable<TSchema>>): Row<Materialized<TSchema>, TRels>;
+    table: TableDef<TSchema, TRels>;
+}
+
+// @public
+export type EntityClassOf<T> = T extends EntityInstance<infer E> ? E : T extends AnyEntityClass ? T : never;
+
+// @public
+export type EntityFields<E extends AnyEntityClass> = Materialized<EntitySchema<E>>;
+
+// Warning: (ae-forgotten-export) The symbol "EntityInstanceFromTable" needs to be exported by the entry point index.d.ts
+//
+// @public
+export type EntityInstance<E extends AnyEntityClass> = E extends new (...args: any[]) => infer R ? R extends EntityBase ? R : EntityInstanceFromTable<E> : EntityInstanceFromTable<E>;
+
+// @public
+export type EntityRelationProps<E extends AnyEntityClass> = {
+    [K in keyof EntityRelations<E>]: RelationQueryable<EntityRelations<E>[K]>;
+};
+
+// @public
+export type EntityRelationPropsLoaded<E extends AnyEntityClass> = {
+    [K in keyof EntityRelations<E>]: RelationLoadedValue<EntityRelations<E>[K]>;
+};
+
+// @public
+export type EntityRelations<E extends AnyEntityClass> = E["table"] extends TableDef<any, infer R> ? R : never;
+
+// @public
+export type EntityRow<E> = E extends AnyEntityClass ? EntityInstance<E> : never;
+
+// @public
+export type EntitySchema<E extends AnyEntityClass> = E["table"] extends TableDef<infer S, any> ? S : never;
+
+// @public
+export interface ExecuteResult {
+    changes: number;
+    lastID?: number;
+    rows: unknown[];
+}
+
+// @public
+export type ExtractSQLBase<S extends string> = StripParens<S> extends `${infer Base} ${string}` ? Lowercase<Base> : Lowercase<StripParens<S>>;
+
+// @public
+export type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+// @public
+export function generateMigrationFiles(driver: Driver, entities: readonly RegisteredEntity[]): Promise<MigrationFile[]>;
+
+// @public
+export function getPkColumnsFromSchema(schema: Record<string, string>): string[];
+
+// @public
+export type HasDefault<S extends string> = Lowercase<S> extends `${string}default${string}` ? true : false;
+
+// @public
+export type InferColumnType<S extends string> = IsNotNull<S> extends true ? SQLToTS<S> : SQLToTS<S> | null;
+
+// @public
+export type InferInsert<T extends Record<string, string>> = Flatten<{
+    -readonly [K in keyof T as OptionalOnInsert<T[K]> extends true ? K : never]?: InferColumnType<T[K]>;
+} & {
+    -readonly [K in keyof T as OptionalOnInsert<T[K]> extends true ? never : K]: InferColumnType<T[K]>;
+}>;
+
+// @public
+export type InferTable<T extends Record<string, string>> = Flatten<{
+    -readonly [K in keyof T]: InferColumnType<T[K]>;
+}>;
+
+// @public
+export class InsertBuilder<C extends AnyEntityClass, R> extends QueryBuilder<C> implements PromiseLike<R> {
+    doNothing(): Promise<R>;
+    doUpdate(updateColumns?: string[]): Promise<R>;
+    onConflict(columns: string[]): this;
+    then<T1 = R, T2 = never>(res?: ((v: R) => T1 | PromiseLike<T1>) | null, rej?: ((e: unknown) => T2 | PromiseLike<T2>) | null): PromiseLike<T1 | T2>;
+}
+
+// @public
+export type IsGenerated<S extends string> = Lowercase<S> extends `${string}autoincrement${string}` ? true : Lowercase<S> extends `${string}auto_increment${string}` ? true : Lowercase<S> extends `${string}generated${string}` ? true : Lowercase<ExtractSQLBase<S>> extends "serial" | "bigserial" ? true : false;
+
+// @public
+export type IsNotNull<S extends string> = Lowercase<S> extends `${string}not null${string}` ? true : Lowercase<S> extends `${string}primary key${string}` ? true : false;
+
+// @public
+export interface JunctionOptions {
+    foreignKey: string | string[];
+    junction: string;
+    referenceKey: string | string[];
+}
+
+// @public
+export function loadConfig(options?: LoadConfigOptions): Promise<TyphexConfig>;
+
+// @public
+export interface LoadConfigOptions {
+    configPath?: string;
+    cwd?: string;
+    overrides?: Partial<TyphexConfig>;
+}
+
+// @public
+export type ManyRelation<E extends EntityBase> = RelationQueryBuilder<E> & E[];
+
+// @public
+export type ManyToMany<E extends AnyEntityClass | EntityBase> = E extends EntityBase ? ManyRelation<E> : RelatedEntityInstance<EntityClassOf<E>, "many">;
+
+// @public
+export function manyToMany<E extends AnyEntityClass>(target: () => E, options: JunctionOptions): RelationDef<E, "many-to-many">;
+
+// @public
+export function manyToMany<TTarget>(target: () => {
+    _selectType: TTarget;
+}, options: JunctionOptions): RelationDef<TTarget, "many-to-many">;
+
+// @public
+export function manyToMany<E extends AnyEntityClass>(target: () => unknown, options: JunctionOptions): RelationDef<E, "many-to-many">;
+
+// @public
+export type ManyToManyDef<E> = RelationDef<E, "many-to-many">;
+
+// @public
+export type ManyToOne<E extends AnyEntityClass | EntityBase> = SingleRelation<ToEntityInstance<E>>;
+
+// @public
+export function manyToOne<E extends AnyEntityClass>(target: () => E, options: RelationOptions): RelationDef<E, "many-to-one">;
+
+// @public
+export function manyToOne<TTarget>(target: () => {
+    _selectType: TTarget;
+}, options: RelationOptions): RelationDef<TTarget, "many-to-one">;
+
+// @public
+export function manyToOne<E extends AnyEntityClass>(target: () => unknown, options: RelationOptions): RelationDef<E, "many-to-one">;
+
+// @public
+export type ManyToOneDef<E> = RelationDef<E, "many-to-one">;
+
+// @public
+export type Materialized<T extends Record<string, string>> = Mutable<{
+    readonly [K in keyof T]: InferColumnType<T[K]>;
+}>;
+
+// @public
+export type MaterializeShape<T extends Record<string, unknown>> = T extends Record<string, string> ? Materialized<T> : Mutable<T>;
+
+// @public
+export function max<T>(_field: T): T;
+
+// @public
+export interface MigrationDb {
+    // (undocumented)
+    run(sql: string, params?: unknown[]): Promise<void>;
+}
+
+// @public (undocumented)
+export interface MigrationDryRun {
+    // (undocumented)
+    applied: MigrationRecord[];
+    // (undocumented)
+    pending: PendingMigration[];
+    // (undocumented)
+    skipped: string[];
+}
+
+// @public
+export interface MigrationFile {
+    content: string;
+    downSql: string;
+    name: string;
+    upSql: string;
+}
+
+// @public
+export interface MigrationRecord {
+    applied_at: string;
+    id: number;
+    name: string;
+}
+
+// @public
+export interface MigrationResult {
+    applied: string[];
+    skipped: string[];
+}
+
+// @public
+export function migrationStatus(driver: Driver, dir: string): Promise<{
+    applied: MigrationRecord[];
+    pending: string[];
+}>;
+
+// @public
+export function min<T>(_field: T): T;
+
+// @public
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+
+// @public
+export type OneToMany<E extends AnyEntityClass | EntityBase> = E extends EntityBase ? ManyRelation<E> : RelatedEntityInstance<EntityClassOf<E>, "many">;
+
+// @public
+export function oneToMany<E extends AnyEntityClass>(target: () => E, options: {
+    foreignKey: string | string[];
+}): RelationDef<E, "one-to-many">;
+
+// @public
+export function oneToMany<TTarget>(target: () => {
+    _selectType: TTarget;
+}, options: {
+    foreignKey: string | string[];
+}): RelationDef<TTarget, "one-to-many">;
+
+// @public
+export function oneToMany<E extends AnyEntityClass>(target: () => unknown, options: {
+    foreignKey: string | string[];
+}): RelationDef<E, "one-to-many">;
+
+// @public
+export type OneToManyDef<E> = RelationDef<E, "one-to-many">;
+
+// @public
+export type OneToOne<E extends AnyEntityClass | EntityBase> = SingleRelation<ToEntityInstance<E>>;
+
+// @public
+export function oneToOne<E extends AnyEntityClass>(target: () => E, options: RelationOptions): RelationDef<E, "one-to-one">;
+
+// @public
+export function oneToOne<TTarget>(target: () => {
+    _selectType: TTarget;
+}, options: RelationOptions): RelationDef<TTarget, "one-to-one">;
+
+// @public
+export function oneToOne<E extends AnyEntityClass>(target: () => unknown, options: RelationOptions): RelationDef<E, "one-to-one">;
+
+// @public
+export type OneToOneDef<E> = RelationDef<E, "one-to-one">;
+
+// @public
+export type OptionalOnInsert<S extends string> = IsGenerated<S> extends true ? true : IsNotNull<S> extends false ? true : HasDefault<S> extends true ? true : false;
+
+// @public
+export type OrderDirection = "asc" | "desc";
+
+// @public (undocumented)
+export interface PendingMigration {
+    // (undocumented)
+    downSql: string;
+    // (undocumented)
+    downStatements: string[];
+    // (undocumented)
+    file: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    statements: string[];
+    // (undocumented)
+    upSql: string;
+}
+
+// @public (undocumented)
+export function pendingMigrations(driver: Driver, dir: string): Promise<PendingMigration[]>;
+
+// @public
+export interface PostgresDriverOptions {
+    connectionString?: string;
+    connectionTimeoutMs?: number;
+    database?: string;
+    host?: string;
+    idleTimeoutMs?: number;
+    logger?: {
+        error: (msg: string, err: Error) => void;
+    };
+    password?: string;
+    poolMax?: number;
+    poolMin?: number;
+    port?: number;
+    ssl?: pg.ConnectionConfig["ssl"];
+    statementTimeoutMs?: number;
+    url?: string;
+    user?: string;
+}
+
+// Warning: (ae-forgotten-export) The symbol "NoCtes" needs to be exported by the entry point index.d.ts
+// Warning: (ae-forgotten-export) The symbol "QueryFromKind" needs to be exported by the entry point index.d.ts
+//
+// @public
+export class QueryBuilder<C extends AnyEntityClass = AnyEntityClass, T = EntityInstance<C>, Ctes extends Record<string, unknown> = NoCtes, FromKind extends QueryFromKind = "table"> {
+    clone(): QueryBuilder<C, T, Ctes, FromKind>;
+    count(): Promise<number>;
+    crossJoin(keysOrFn: string[] | ((row: T) => unknown)): this;
+    delete(): Promise<number>;
+    deleteReturning(): Promise<EntityInstance<C>[]>;
+    findById(id: unknown): Promise<EntityInstance<C> | null>;
+    first(): Promise<EntityInstance<C> | undefined>;
+    from<N extends keyof Ctes & string>(name: N): QueryBuilder<C, Ctes[N], Ctes, "cte">;
+    // (undocumented)
+    from<Row = EntityInstance<C>>(name: string): QueryBuilder<C, Row, Ctes, "cte">;
+    // (undocumented)
+    from<Row>(source: QueryBuilder<any, Row>): QueryBuilder<C, Row, Ctes, "table">;
+    // (undocumented)
+    from(): QueryBuilder<C, EntityInstance<C>, Ctes, "table">;
+    fullJoin(keysOrFn: string[] | ((row: T) => unknown)): this;
+    // (undocumented)
+    fullJoin<E extends AnyEntityClass>(entity: E, on: (joined: EntityInstance<E>, row: T) => boolean): this;
+    groupBy(columnOrFn: string | string[] | number | number[] | ((row: EntityInstance<C>) => unknown), ...rest: (string | number)[]): this;
+    having(predicate: HasRegisteredCtes<Ctes> extends true ? (row: EntityInstance<C>, ctes: RegisteredCtes<Ctes>) => boolean : (row: EntityInstance<C>) => boolean, params?: Record<string, unknown>): this;
+    innerJoin(keysOrFn: string[] | ((row: T) => unknown)): this;
+    // (undocumented)
+    innerJoin<E extends AnyEntityClass>(entity: E, on: (joined: EntityInstance<E>, row: T) => boolean): this;
+    insert(row: Record<string, unknown>): InsertBuilder<C, EntityInstance<C> | undefined>;
+    insertGraph(graph: Record<string, unknown>): Promise<EntityInstance<C>>;
+    insertGraph(graphs: Record<string, unknown>[]): Promise<EntityInstance<C>[]>;
+    insertMany(rows: Record<string, unknown>[]): InsertBuilder<C, EntityInstance<C>[]>;
+    leftJoin(keysOrFn: string[] | ((row: T) => unknown)): this;
+    // (undocumented)
+    leftJoin<E extends AnyEntityClass>(entity: E, on: (joined: EntityInstance<E>, row: T) => boolean): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    orderBy(col: string | ((row: T) => unknown), direction?: OrderDirection): this;
+    patch(set: Record<string, unknown>): Promise<EntityInstance<C> | null>;
+    // (undocumented)
+    protected requirePkColumns(context: string): string[];
+    rightJoin(keysOrFn: string[] | ((row: T) => unknown)): this;
+    // (undocumented)
+    rightJoin<E extends AnyEntityClass>(entity: E, on: (joined: EntityInstance<E>, row: T) => boolean): this;
+    select<U>(fn: (row: SelectRow<C>) => U): QueryBuilder<C, U, Ctes>;
+    select(columns: string[]): QueryBuilder<C, T, Ctes>;
+    toArray(): Promise<EntityInstance<C>[]>;
+    unionAll<OC extends AnyEntityClass, OT>(other: QueryBuilder<OC, OT, any, any>): QueryBuilder<C, T, Ctes, FromKind>;
+    update(set: Record<string, unknown>): Promise<number>;
+    // (undocumented)
+    update(setFn: HasRegisteredCtes<Ctes> extends true ? (row: EntityInstance<C>, ctes: RegisteredCtes<Ctes>) => Record<string, unknown> : (row: EntityInstance<C>) => Record<string, unknown>): Promise<number>;
+    updateReturning(set: Record<string, unknown>): Promise<EntityInstance<C>[]>;
+    // (undocumented)
+    updateReturning(setFn: HasRegisteredCtes<Ctes> extends true ? (row: EntityInstance<C>, ctes: RegisteredCtes<Ctes>) => Record<string, unknown> : (row: EntityInstance<C>) => Record<string, unknown>): Promise<EntityInstance<C>[]>;
+    // Warning: (ae-forgotten-export) The symbol "HasRegisteredCtes" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "TableRow" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "RegisteredCtes" needs to be exported by the entry point index.d.ts
+    where(predicate: FromKind extends "cte" ? (row: T) => boolean : HasRegisteredCtes<Ctes> extends true ? (row: TableRow<C, T, FromKind>, ctes: RegisteredCtes<Ctes>) => boolean : (row: TableRow<C, T, FromKind>) => boolean, params?: Record<string, unknown>): this;
+    // (undocumented)
+    withCte<const N extends string, IC extends AnyEntityClass, IT>(name: N, subquery: QueryBuilder<IC, IT, any, any>): QueryBuilder<C, T, Ctes & Record<N, IT>, FromKind>;
+    // (undocumented)
+    withCte<const N extends string, IC extends AnyEntityClass, IT>(name: N, build: (ctes: RegisteredCtes<Ctes>) => QueryBuilder<IC, IT, any, any>): QueryBuilder<C, T, Ctes & Record<N, IT>, FromKind>;
+    withRecursiveCte<const N extends string, IC extends AnyEntityClass, IT>(name: N, subquery: QueryBuilder<IC, IT, any, any>): QueryBuilder<C, T, Ctes & Record<N, IT>, FromKind>;
+}
+
+// @public
+export interface QueryExecutor {
+    readonly dialect: DialectInfo;
+    query(sql: string, params?: unknown[]): Promise<unknown[]>;
+    run(sql: string, params?: unknown[]): Promise<{
+        lastID?: number;
+        changes: number;
+    }>;
+}
+
+// @public
+export interface RegisteredEntity {
+    _registerJunctions?: () => void;
+    table: {
+        _table: string;
+        _schema: Record<string, string>;
+    };
+}
+
+// @public
+export const rel: {
+    oneToOne: typeof oneToOne;
+    manyToOne: typeof manyToOne;
+    oneToMany: typeof oneToMany;
+    manyToMany: typeof manyToMany;
+};
+
+// @public
+export type RelatedEntityInstance<E extends AnyEntityClass, Kind extends "one" | "many"> = Kind extends "many" ? RelationQueryBuilder<SelectRow<E>> & EntityInstance<E>[] : SingleRelation<EntityInstance<E>>;
+
+// @public
+export interface RelationDef<_E = unknown, TType extends RelationType = RelationType> {
+    readonly _options: RelationOptions | JunctionOptions;
+    readonly _relType: TType;
+    readonly _target: () => unknown;
+}
+
+// @public
+export type RelationKind<TType extends RelationType> = TType extends "one-to-many" | "many-to-many" ? "many" : "one";
+
+// @public
+export type RelationLoadedValue<R> = R extends RelationDef<infer E, infer TType> ? E extends AnyEntityClass ? unknown extends E ? TType extends "one-to-many" | "many-to-many" ? RelationQueryBuilder<any> & EntityBase[] : EntityBase : TType extends "one-to-many" | "many-to-many" ? ManyRelation<EntityInstance<E>> : EntityInstance<E> : TType extends "one-to-many" | "many-to-many" ? RelationQueryBuilder<any> & EntityBase[] : EntityBase : never;
+
+// @public
+export interface RelationOptions {
+    foreignKey: string | string[];
+    references?: string | string[];
+}
+
+// @public
+export type RelationQueryable<R> = R extends RelationDef<infer E, infer TType> ? E extends AnyEntityClass ? RelatedEntityInstance<E, RelationKind<TType>> : TType extends "one-to-many" | "many-to-many" ? RelationQueryBuilder<E> & E[] : RelationQueryBuilder<E> & E : never;
+
+// @public
+export interface RelationQueryBuilder<T> {
+    count(): Promise<number>;
+    first(): Promise<T | undefined>;
+    limit(n: number): RelationQueryBuilder<T>;
+    offset(n: number): RelationQueryBuilder<T>;
+    orderBy(col: string, dir?: string): RelationQueryBuilder<T>;
+    query(): RelationQueryBuilder<T>;
+    select<U>(fn: (row: T) => U): RelationQueryBuilder<U>;
+    toArray(): Promise<T[]>;
+    where(fn: (row: T) => boolean): RelationQueryBuilder<T>;
+}
+
+// @public
+export type RelationsMap = Record<string, RelationDef<any, RelationType>>;
+
+// @public
+export type RelationTarget<R> = R extends RelationDef<infer E, any> ? (E extends AnyEntityClass ? EntityInstance<E> : E) : never;
+
+// @public
+export type RelationType = "one-to-one" | "many-to-one" | "one-to-many" | "many-to-many";
+
+// @public
+export type Row<TShape extends Record<string, unknown>, TRels extends RelationsMap = {}> = Flatten<MaterializeShape<TShape> & {
+    [K in keyof TRels]: RelationLoadedValue<TRels[K]>;
+}> & EntityBase;
+
+// @public
+export function runMigrations(driver: Driver, dir: string): Promise<MigrationResult>;
+
+// Warning: (ae-forgotten-export) The symbol "SelectRowFromTable" needs to be exported by the entry point index.d.ts
+//
+// @public
+export type SelectRow<E extends AnyEntityClass> = E extends new (...args: any[]) => infer R ? R extends EntityBase ? R : SelectRowFromTable<E> : SelectRowFromTable<E>;
+
+// @public
+export type SingleRelation<E extends EntityBase> = E;
+
+// @public
+export class SingleRowQueryBuilder<T = unknown> {
+    delete(): Promise<void>;
+    patch(set: Record<string, unknown>): Promise<void>;
+    save(): Promise<void>;
+}
+
+// @public
+export interface SqliteDriverOptions {
+    database?: string;
+    path?: string;
+}
+
+// @public
+export type SQLToTS<S extends string> = ExtractSQLBase<S> extends keyof SQLTypeMap ? SQLTypeMap[ExtractSQLBase<S>] : unknown;
+
+// @public
+export type SQLTypeMap = {
+    integer: number;
+    int: number;
+    serial: number;
+    smallint: number;
+    tinyint: number;
+    real: number;
+    float: number;
+    double: number;
+    numeric: number;
+    decimal: number;
+    text: string;
+    varchar: string;
+    char: string;
+    nvarchar: string;
+    uuid: string;
+    boolean: boolean;
+    bool: boolean;
+    date: Date;
+    datetime: Date;
+    timestamp: Date;
+    blob: Uint8Array;
+    json: unknown;
+    jsonb: unknown;
+    bigint: bigint;
+    bigserial: bigint;
+};
+
+// @public
+export type StripParens<S extends string> = S extends `${infer Base}(${string})${infer Rest}` ? `${Base}${Rest}` : S;
+
+// @public
+export function sum(_field: number): number;
+
+// @public
+export interface TableDef<TSchema extends Record<string, string>, TRelations extends RelationsMap = Record<string, never>> {
+    readonly _insertType: InferInsert<TSchema>;
+    readonly _relations: TRelations;
+    readonly _schema: TSchema;
+    readonly _selectType: InferTable<TSchema>;
+    readonly _table: string;
+}
+
+// @public
+export type ToEntityInstance<E> = E extends EntityBase ? E : EntityInstance<EntityClassOf<E>>;
+
+// @public
+export interface TransactionOptions {
+    deferrable?: boolean;
+    isolationLevel?: "READ_UNCOMMITTED" | "READ_COMMITTED" | "REPEATABLE_READ" | "SERIALIZABLE";
+    readOnly?: boolean;
+    sqliteMode?: "deferred" | "immediate" | "exclusive";
+}
+
+// @public
+export abstract class Trx {
+    protected abstract begin(): Promise<void>;
+    beginTrx(): Promise<Trx>;
+    abstract commit(): Promise<void>;
+    static readonly defaultOptions: TransactionOptions;
+    get dialect(): DialectInfo;
+    query(sql: string, params?: unknown[]): Promise<unknown[]>;
+    abstract rollback(): Promise<void>;
+    run(sql: string, params?: unknown[]): Promise<{
+        lastID?: number;
+        changes: number;
+    }>;
+    transaction<T>(fn: (trx: Trx) => Promise<T>): Promise<T>;
+    protected validateOptions(): void;
+}
+
+// @public
+export interface TyphexConfig {
+    database?: string;
+    dialect: DialectName;
+    entities?: string;
+    migrationsFolder?: string;
+    url?: string;
+}
+
+// @public (undocumented)
+export function upMigration(driver: Driver, dir: string, name: string): Promise<void>;
+
+// @public
+export interface WithClause {
+    // (undocumented)
+    inner: unknown;
+    // (undocumented)
+    kind: "simple" | "recursive";
+    // (undocumented)
+    name: string;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```