@bjnstnkvc/db 0.1.0

package/dist/main.d.cts

@@ -0,0 +1,1372 @@
+type Enumerable = readonly string[] | Record<string, string | number>;
+type ColumnType = 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'json' | 'decimal' | 'enum';
+interface ColumnSchema {
+    name: string;
+    type: ColumnType;
+    nullable: boolean;
+    default: unknown;
+    hasDefault: boolean;
+    primary: boolean;
+    increments: boolean;
+    places: number | null;
+    values: string[] | null;
+}
+interface IndexSchema {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    multiEntry: boolean;
+}
+interface TableSchema {
+    table: string;
+    key: string | null;
+    increments: boolean;
+    timestamps: boolean;
+    columns: ColumnSchema[];
+    indexes: IndexSchema[];
+}
+interface RenamedColumn {
+    from: string;
+    to: string;
+}
+interface BlueprintOperations {
+    added: ColumnSchema[];
+    dropped: string[];
+    renamed: RenamedColumn[];
+    indexed: IndexSchema[];
+    unindexed: string[];
+}
+interface RequestedIndex {
+    name: string | null;
+    unique: boolean;
+    multiEntry: boolean;
+}
+
+declare class ColumnDefinition {
+    #private;
+    /**
+     * Create a new column definition.
+     */
+    constructor(name: string, type: ColumnType);
+    /**
+     * Get the name of the column.
+     */
+    get name(): string;
+    /**
+     * Get the declared type of the column.
+     */
+    get type(): ColumnType;
+    /**
+     * Record the scale of a decimal column.
+     */
+    scaled(places: number): this;
+    /**
+     * Record the values an enumerated column accepts.
+     */
+    accepts(values: string[]): this;
+    /**
+     * Allow the column to hold a null value.
+     */
+    nullable(value?: boolean): this;
+    /**
+     * Set the value applied when the column is absent.
+     */
+    default(value: unknown): this;
+    /**
+     * Make the column the key path of its table.
+     */
+    primary(): this;
+    /**
+     * Let the database generate the column value.
+     */
+    increments(): this;
+    /**
+     * Request an index over the column.
+     */
+    index(name?: string | null): this;
+    /**
+     * Request a unique index over the column.
+     */
+    unique(name?: string | null): this;
+    /**
+     * Index each element of the column's array value, requesting an index when none was.
+     */
+    multiEntry(): this;
+    /**
+     * Get the indexes requested for the column.
+     */
+    requested(): RequestedIndex[];
+    /**
+     * Get the schema describing the column.
+     */
+    toSchema(): ColumnSchema;
+}
+
+declare class Blueprint {
+    #private;
+    /**
+     * Create a new blueprint for a table.
+     */
+    constructor(table: string, existing?: TableSchema | null);
+    /**
+     * Get the name of the table.
+     */
+    get table(): string;
+    /**
+     * Add an auto incrementing primary key column.
+     */
+    id(column?: string): ColumnDefinition;
+    /**
+     * Add a string column holding a universally unique identifier.
+     */
+    uuid(column: string): ColumnDefinition;
+    /**
+     * Add a string column.
+     */
+    string(column: string): ColumnDefinition;
+    /**
+     * Add an integer column.
+     */
+    integer(column: string): ColumnDefinition;
+    /**
+     * Add a floating point column.
+     */
+    float(column: string): ColumnDefinition;
+    /**
+     * Add a boolean column.
+     */
+    boolean(column: string): ColumnDefinition;
+    /**
+     * Add a date column.
+     */
+    date(column: string): ColumnDefinition;
+    /**
+     * Add a date and time column.
+     */
+    datetime(column: string): ColumnDefinition;
+    /**
+     * Add a column holding an arbitrary structure.
+     */
+    json(column: string): ColumnDefinition;
+    /**
+     * Add a fixed point column, stored as an integer number of its smallest unit.
+     */
+    decimal(column: string, places?: number): ColumnDefinition;
+    /**
+     * Add a column accepting only one of the given values.
+     */
+    enum(column: string, values: Enumerable): ColumnDefinition;
+    /**
+     * Add nullable creation and update timestamp columns.
+     */
+    timestamps(): void;
+    /**
+     * Add an index over the given columns.
+     */
+    index(columns: string | string[], name?: string | null): IndexSchema;
+    /**
+     * Add a unique index over the given columns.
+     */
+    unique(columns: string | string[], name?: string | null): IndexSchema;
+    /**
+     * Drop the given columns from the table.
+     */
+    dropColumn(...columns: string[]): void;
+    /**
+     * Rename a column of the table.
+     */
+    renameColumn(from: string, to: string): void;
+    /**
+     * Drop an index from the table.
+     */
+    dropIndex(name: string): void;
+    /**
+     * Get the schema describing the table once the blueprint is applied.
+     */
+    toSchema(): TableSchema;
+    /**
+     * Get the operations the blueprint performs against the existing table.
+     */
+    operations(): BlueprintOperations;
+}
+
+type Key<T> = (keyof T & string) | (string & {});
+type Operator = '=' | '==' | '===' | '!=' | '<>' | '!==' | '<' | '>' | '<=' | '>=' | 'like' | 'not like';
+type Conjunction = 'and' | 'or';
+type Direction = 'asc' | 'desc';
+type DatePart = 'year' | 'month' | 'day';
+type Constraint = {
+    type: 'basic';
+    column: string;
+    operator: Operator;
+    value: unknown;
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'in';
+    column: string;
+    values: unknown[];
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'null';
+    column: string;
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'between';
+    column: string;
+    from: unknown;
+    to: unknown;
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'column';
+    column: string;
+    operator: Operator;
+    other: string;
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'part';
+    column: string;
+    part: DatePart;
+    value: number;
+    conjunction: Conjunction;
+    not: boolean;
+} | {
+    type: 'nested';
+    constraints: Constraint[];
+    conjunction: Conjunction;
+    not: boolean;
+};
+interface Order {
+    column: string;
+    direction: Direction;
+}
+interface Plan {
+    source: 'key' | 'index' | 'scan';
+    index: string | null;
+    range: IDBKeyRange | null;
+    values: unknown[] | null;
+    direction: IDBCursorDirection;
+    ordered: boolean;
+    residual: Constraint[];
+}
+type JoinType = 'inner' | 'left' | 'right' | 'cross';
+interface JoinCondition {
+    first: string;
+    operator: Operator;
+    second: string;
+    conjunction: Conjunction;
+}
+interface JoinClause {
+    table: string;
+    type: JoinType;
+    conditions: JoinCondition[];
+}
+interface Projection {
+    column: string;
+    alias: string;
+}
+interface Paginated<T> {
+    data: T[];
+    total: number;
+    perPage: number;
+    currentPage: number;
+    lastPage: number;
+}
+type Aggregation = {
+    count: '*' | (string & {});
+} | {
+    sum: string;
+} | {
+    avg: string;
+} | {
+    min: string;
+} | {
+    max: string;
+};
+type Aggregations = Record<string, Aggregation>;
+type Aggregated<A extends Aggregation> = A extends {
+    count: unknown;
+} ? number : number | null;
+type Grouped<T, G extends (keyof T & string)[], A extends Aggregations> = {
+    [K in G[number]]: T[K];
+} & {
+    [K in keyof A]: Aggregated<A[K]>;
+};
+
+declare class Join {
+    #private;
+    /**
+     * Join on a pair of columns.
+     */
+    on(first: string, operator: Operator | string, second?: string): this;
+    /**
+     * Join on a pair of columns, disjunctively.
+     */
+    orOn(first: string, operator: Operator | string, second?: string): this;
+    /**
+     * Get the conditions the tables are joined on.
+     */
+    conditions(): JoinCondition[];
+}
+
+type Records = () => Promise<Record<string, unknown>[]>;
+declare class Grouping<T, G extends (keyof T & string)[], A extends Aggregations = Record<string, never>> {
+    #private;
+    /**
+     * Create a new grouping.
+     */
+    constructor(records: Records, columns: G);
+    /**
+     * Compute the given aggregations for each group.
+     */
+    aggregate<N extends Aggregations>(aggregations: N): Grouping<T, G, N>;
+    /**
+     * Constrain the groups the query returns.
+     */
+    having(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    /**
+     * Add a disjunctive constraint on the groups the query returns.
+     */
+    orHaving(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    /**
+     * Sort the groups by a column or an aggregate.
+     */
+    orderBy(column: Key<Grouped<T, G, A>>, direction?: Direction): this;
+    /**
+     * Limit the number of groups the query returns.
+     */
+    limit(value: number): this;
+    /**
+     * Skip the given number of groups.
+     */
+    offset(value: number): this;
+    /**
+     * Get every group matching the query.
+     */
+    get(): Promise<Grouped<T, G, A>[]>;
+    /**
+     * Get the first group matching the query.
+     */
+    first(): Promise<Grouped<T, G, A> | null>;
+    /**
+     * Count the groups matching the query.
+     */
+    count(): Promise<number>;
+}
+
+declare class Transaction {
+    #private;
+    /**
+     * Create a new transaction.
+     */
+    constructor(connection: Connection, transaction: IDBTransaction);
+    /**
+     * Get the names of the tables the transaction is scoped to.
+     */
+    get tables(): string[];
+    /**
+     * Begin a query against a table inside the transaction.
+     */
+    table<T = Record<string, unknown>>(name: string): Builder<T>;
+}
+
+declare abstract class Migration {
+    /**
+     * Run the migration.
+     */
+    abstract up(): void | Promise<void>;
+    /**
+     * Get the name of the migration.
+     */
+    name(): string;
+}
+
+type MigrationConstructor = new () => Migration;
+interface MigrationStatus {
+    migration: string;
+    ran: boolean;
+    at: string | null;
+}
+
+declare abstract class Seeder {
+    /**
+     * Seed the database.
+     */
+    abstract run(): void | Promise<void>;
+    /**
+     * Get the name of the seeder.
+     */
+    name(): string;
+}
+
+type SeederConstructor = new () => Seeder;
+
+interface ConnectionConfig {
+    database: string;
+    migrations?: MigrationConstructor[];
+    seeders?: SeederConstructor[];
+    strict?: boolean;
+}
+interface FreshOptions {
+    seed?: boolean;
+}
+interface DatabaseConfig {
+    default: string;
+    connections: Record<string, ConnectionConfig>;
+}
+interface TransactionOptions {
+    tables?: string[];
+}
+interface QueryLogEntry {
+    connection: string;
+    table: string;
+    plan: string;
+    duration: number;
+    records: number;
+}
+interface ListenOptions {
+    once?: boolean;
+}
+
+declare class Connection {
+    #private;
+    /**
+     * Create a new connection.
+     */
+    constructor(name: string, config: ConnectionConfig);
+    /**
+     * Get the name of the connection.
+     */
+    get name(): string;
+    /**
+     * Get the name of the underlying database.
+     */
+    get database(): string;
+    /**
+     * Determine whether the connection enforces its column declarations.
+     */
+    get strict(): boolean;
+    /**
+     * Get the migrations registered on the connection.
+     */
+    get migrations(): MigrationConstructor[];
+    /**
+     * Get the seeders registered on the connection.
+     */
+    get seeders(): SeederConstructor[];
+    /**
+     * Open the underlying database, running any pending migrations.
+     */
+    open(): Promise<IDBDatabase>;
+    /**
+     * Run any pending migrations, returning the names of those this call ran.
+     */
+    migrate(): Promise<string[]>;
+    /**
+     * Run every registered seeder, returning their names.
+     */
+    seed(): Promise<string[]>;
+    /**
+     * Delete the database and replay every migration.
+     */
+    fresh(options?: FreshOptions): Promise<string[]>;
+    /**
+     * Get the state of every registered migration, without running any of them.
+     */
+    status(): Promise<MigrationStatus[]>;
+    /**
+     * Begin a query against a table.
+     */
+    table<T = Record<string, unknown>>(table: string, transaction?: IDBTransaction | null): Builder<T>;
+    /**
+     * Run the callback inside a transaction, committing when it resolves.
+     */
+    transaction<R>(callback: (transaction: Transaction) => R | Promise<R>, options?: TransactionOptions): Promise<R>;
+    /**
+     * Get the schema of a table.
+     */
+    schema(table: string): Promise<TableSchema>;
+    /**
+     * Get the names of every table.
+     */
+    tables(): Promise<string[]>;
+    /**
+     * Determine whether a table exists.
+     */
+    hasTable(table: string): Promise<boolean>;
+    /**
+     * Determine whether a table has a column.
+     */
+    hasColumn(table: string, column: string): Promise<boolean>;
+    /**
+     * Get the columns of a table.
+     */
+    getColumns(table: string): Promise<ColumnSchema[]>;
+    /**
+     * Get the indexes of a table.
+     */
+    getIndexes(table: string): Promise<IndexSchema[]>;
+    /**
+     * Close the underlying database.
+     */
+    disconnect(): void;
+}
+
+type Nested<T> = (query: Builder<T>) => void;
+type Joining = (join: Join) => void;
+type Column<T> = Key<T> | Partial<T> | Nested<T>;
+declare class Builder<T = Record<string, unknown>> {
+    #private;
+    /**
+     * Create a new query builder.
+     */
+    constructor(connection: Connection, table: string, transaction?: IDBTransaction | null);
+    /**
+     * Get the name of the table the query runs against.
+     */
+    get table(): string;
+    /**
+     * Add a constraint to the query.
+     */
+    where(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    /**
+     * Add a disjunctive constraint to the query.
+     */
+    orWhere(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    /**
+     * Add a negated constraint to the query.
+     */
+    whereNot(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    /**
+     * Constrain a column to one of the given values.
+     */
+    whereIn(column: Key<T>, values: unknown[]): this;
+    /**
+     * Constrain a column to one of the given values, disjunctively.
+     */
+    orWhereIn(column: Key<T>, values: unknown[]): this;
+    /**
+     * Constrain a column to none of the given values.
+     */
+    whereNotIn(column: Key<T>, values: unknown[]): this;
+    /**
+     * Constrain a column to none of the given values, disjunctively.
+     */
+    orWhereNotIn(column: Key<T>, values: unknown[]): this;
+    /**
+     * Constrain a column to be null.
+     */
+    whereNull(column: Key<T>): this;
+    /**
+     * Constrain a column to be null, disjunctively.
+     */
+    orWhereNull(column: Key<T>): this;
+    /**
+     * Constrain a column to not be null.
+     */
+    whereNotNull(column: Key<T>): this;
+    /**
+     * Constrain a column to not be null, disjunctively.
+     */
+    orWhereNotNull(column: Key<T>): this;
+    /**
+     * Constrain a column to fall between two values, inclusive.
+     */
+    whereBetween(column: Key<T>, values: [unknown, unknown]): this;
+    /**
+     * Constrain a column to fall between two values, disjunctively.
+     */
+    orWhereBetween(column: Key<T>, values: [unknown, unknown]): this;
+    /**
+     * Constrain a column to fall outside two values.
+     */
+    whereNotBetween(column: Key<T>, values: [unknown, unknown]): this;
+    /**
+     * Constrain a column to fall outside two values, disjunctively.
+     */
+    orWhereNotBetween(column: Key<T>, values: [unknown, unknown]): this;
+    /**
+     * Constrain a column to match a pattern.
+     */
+    whereLike(column: Key<T>, pattern: string): this;
+    /**
+     * Constrain a column to match a pattern, disjunctively.
+     */
+    orWhereLike(column: Key<T>, pattern: string): this;
+    /**
+     * Constrain a column to not match a pattern.
+     */
+    whereNotLike(column: Key<T>, pattern: string): this;
+    /**
+     * Constrain a column to not match a pattern, disjunctively.
+     */
+    orWhereNotLike(column: Key<T>, pattern: string): this;
+    /**
+     * Constrain a date column to fall on a given day.
+     */
+    whereDate(column: Key<T>, value: Date | string): this;
+    /**
+     * Constrain a date column to fall in a given year.
+     */
+    whereYear(column: Key<T>, value: number): this;
+    /**
+     * Constrain a date column to fall in a given month, numbered from one.
+     */
+    whereMonth(column: Key<T>, value: number): this;
+    /**
+     * Constrain a date column to fall on a given day of the month.
+     */
+    whereDay(column: Key<T>, value: number): this;
+    /**
+     * Join another table, keeping only the rows that match.
+     */
+    join<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    /**
+     * Join another table, keeping every row of this one.
+     */
+    leftJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    /**
+     * Join another table, keeping every row of it.
+     */
+    rightJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    /**
+     * Pair every row of this table with every row of another.
+     */
+    crossJoin<R = Record<string, unknown>>(table: string): Builder<R>;
+    /**
+     * Constrain a column against another column of the same row.
+     */
+    whereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    /**
+     * Constrain a column against another column of the same row, disjunctively.
+     */
+    orWhereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    /**
+     * Project only the given columns, which may alias what they select.
+     */
+    select(...columns: (Key<T> | Key<T>[])[]): this;
+    /**
+     * Remove duplicate records from the result.
+     */
+    distinct(value?: boolean): this;
+    /**
+     * Group the matching records by one or more columns.
+     */
+    groupBy<G extends (keyof T & string)[]>(...columns: G): Grouping<T, G>;
+    /**
+     * Sort the result by a column.
+     */
+    orderBy(column: Key<T>, direction?: Direction): this;
+    /**
+     * Sort the result by a column, newest first.
+     */
+    latest(column?: Key<T>): this;
+    /**
+     * Sort the result by a column, oldest first.
+     */
+    oldest(column?: Key<T>): this;
+    /**
+     * Limit the number of records the query returns.
+     */
+    limit(value: number): this;
+    /**
+     * Limit the number of records the query returns.
+     */
+    take(value: number): this;
+    /**
+     * Skip the given number of records.
+     */
+    offset(value: number): this;
+    /**
+     * Skip the given number of records.
+     */
+    skip(value: number): this;
+    /**
+     * Limit the query to a single page of records.
+     */
+    forPage(page: number, perPage?: number): this;
+    /**
+     * Apply the callback when the value is truthy.
+     */
+    when(value: unknown, callback: (query: this, value: unknown) => void): this;
+    /**
+     * Apply the callback when the value is falsy.
+     */
+    unless(value: unknown, callback: (query: this, value: unknown) => void): this;
+    /**
+     * Pass the query to the callback and carry on.
+     */
+    tap(callback: (query: this) => void): this;
+    /**
+     * Get a copy of the query.
+     */
+    clone(): Builder<T>;
+    /**
+     * Dump the state of the query.
+     */
+    dump(): this;
+    /**
+     * Describe the plan the query would run under.
+     */
+    explain(): Promise<string>;
+    /**
+     * Get every record matching the query.
+     */
+    get(): Promise<T[]>;
+    /**
+     * Get the first record matching the query.
+     */
+    first(): Promise<T | null>;
+    /**
+     * Get the first record matching the query, or fail.
+     */
+    firstOrFail(): Promise<T>;
+    /**
+     * Get the one record matching the query, failing when there is not exactly one.
+     */
+    sole(): Promise<T>;
+    /**
+     * Get the record with the given key.
+     */
+    find(key: IDBValidKey): Promise<T | null>;
+    /**
+     * Get the record with the given key, or fail.
+     */
+    findOrFail(key: IDBValidKey): Promise<T>;
+    /**
+     * Get a single column from the first record matching the query.
+     */
+    value<V = unknown>(column: Key<T>): Promise<V | null>;
+    /**
+     * Get a single column from every record matching the query.
+     */
+    pluck<V = unknown>(column: Key<T>): Promise<V[]>;
+    pluck<V = unknown>(column: Key<T>, key: Key<T>): Promise<Record<string, V>>;
+    /**
+     * Determine whether any record matches the query.
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Determine whether no record matches the query.
+     */
+    doesntExist(): Promise<boolean>;
+    /**
+     * Count the records matching the query.
+     */
+    count(): Promise<number>;
+    /**
+     * Sum a column across the records matching the query.
+     */
+    sum(column: Key<T>): Promise<number>;
+    /**
+     * Average a column across the records matching the query.
+     */
+    avg(column: Key<T>): Promise<number | null>;
+    /**
+     * Get the smallest value of a column across the records matching the query.
+     */
+    min(column: Key<T>): Promise<number | null>;
+    /**
+     * Get the largest value of a column across the records matching the query.
+     */
+    max(column: Key<T>): Promise<number | null>;
+    /**
+     * Get a single page of records, alongside the totals a pager needs.
+     */
+    paginate(page?: number, perPage?: number): Promise<Paginated<T>>;
+    /**
+     * Walk the records matching the query in chunks.
+     */
+    chunk(size: number, callback: (records: T[], page: number) => unknown): Promise<boolean>;
+    /**
+     * Walk the records matching the query as an async iterable.
+     */
+    lazy(size?: number): AsyncGenerator<T, void, undefined>;
+    /**
+     * Walk the records matching the query one at a time.
+     */
+    each(callback: (record: T, index: number) => unknown): Promise<boolean>;
+    /**
+     * Insert one or more records into the table.
+     */
+    insert(records: Partial<T> | Partial<T>[]): Promise<number>;
+    /**
+     * Insert one or more records, skipping any the unique indexes reject.
+     */
+    insertOrIgnore(records: Partial<T> | Partial<T>[]): Promise<number>;
+    /**
+     * Insert a record and get the key the database gave it.
+     */
+    insertGetId(record: Partial<T>): Promise<IDBValidKey>;
+    /**
+     * Update every record matching the query.
+     */
+    update(values: Partial<T>): Promise<number>;
+    /**
+     * Update the matching record, inserting it when there is none.
+     */
+    updateOrInsert(attributes: Partial<T>, values?: Partial<T>): Promise<boolean>;
+    /**
+     * Insert records, updating those that already exist.
+     */
+    upsert(values: Partial<T>[], uniqueBy: Key<T> | Key<T>[], update?: Key<T>[]): Promise<number>;
+    /**
+     * Add the given amount to a column of every record matching the query.
+     */
+    increment(column: Key<T>, amount?: number, extra?: Partial<T>): Promise<number>;
+    /**
+     * Subtract the given amount from a column of every record matching the query.
+     */
+    decrement(column: Key<T>, amount?: number, extra?: Partial<T>): Promise<number>;
+    /**
+     * Delete every record matching the query.
+     */
+    delete(): Promise<number>;
+    /**
+     * Delete every record in the table.
+     */
+    truncate(): Promise<void>;
+}
+
+declare class DatabaseBlocked extends Event {
+    #private;
+    /**
+     * Create a new Database Blocked event instance.
+     */
+    constructor(database: string);
+    /**
+     * Get the name of the database.
+     */
+    get database(): string;
+}
+
+declare class MigrationEnded extends Event {
+    #private;
+    /**
+     * Create a new Migration Ended event instance.
+     */
+    constructor(migration: string);
+    /**
+     * Get the name of the migration.
+     */
+    get migration(): string;
+}
+
+declare class MigrationsEnded extends Event {
+    #private;
+    /**
+     * Create a new Migrations Ended event instance.
+     */
+    constructor(connection: string, migrations: string[]);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+    /**
+     * Get the names of the migrations.
+     */
+    get migrations(): string[];
+}
+
+declare class MigrationsStarted extends Event {
+    #private;
+    /**
+     * Create a new Migrations Started event instance.
+     */
+    constructor(connection: string, migrations: string[]);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+    /**
+     * Get the names of the migrations.
+     */
+    get migrations(): string[];
+}
+
+declare class MigrationStarted extends Event {
+    #private;
+    /**
+     * Create a new Migration Started event instance.
+     */
+    constructor(migration: string);
+    /**
+     * Get the name of the migration.
+     */
+    get migration(): string;
+}
+
+declare class NoPendingMigrations extends Event {
+    #private;
+    /**
+     * Create a new No Pending Migrations event instance.
+     */
+    constructor(connection: string);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+}
+
+declare class QueryExecuted extends Event {
+    #private;
+    /**
+     * Create a new Query Executed event instance.
+     */
+    constructor(connection: string, table: string, plan: string, constraints: Constraint[], orders: Order[], limit: number | null, duration: number, records: number);
+    /**
+     * Get the name of the connection the query ran on.
+     */
+    get connection(): string;
+    /**
+     * Get the name of the table the query ran against.
+     */
+    get table(): string;
+    /**
+     * Get the description of the plan the query ran under.
+     */
+    get plan(): string;
+    /**
+     * Get the constraints the query was compiled from.
+     */
+    get constraints(): Constraint[];
+    /**
+     * Get the orders the query was compiled from.
+     */
+    get orders(): Order[];
+    /**
+     * Get the maximum number of records the query was allowed to return.
+     */
+    get limit(): number | null;
+    /**
+     * Get the time the query took in milliseconds.
+     */
+    get duration(): number;
+    /**
+     * Get the number of records the query returned or affected.
+     */
+    get records(): number;
+}
+
+declare class SeederEnded extends Event {
+    #private;
+    /**
+     * Create a new Seeder Ended event instance.
+     */
+    constructor(seeder: string);
+    /**
+     * Get the name of the seeder.
+     */
+    get seeder(): string;
+}
+
+declare class SeederStarted extends Event {
+    #private;
+    /**
+     * Create a new Seeder Started event instance.
+     */
+    constructor(seeder: string);
+    /**
+     * Get the name of the seeder.
+     */
+    get seeder(): string;
+}
+
+declare class SeedingEnded extends Event {
+    #private;
+    /**
+     * Create a new Seeding Ended event instance.
+     */
+    constructor(connection: string, seeders: string[]);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+    /**
+     * Get the names of the seeders.
+     */
+    get seeders(): string[];
+}
+
+declare class SeedingStarted extends Event {
+    #private;
+    /**
+     * Create a new Seeding Started event instance.
+     */
+    constructor(connection: string, seeders: string[]);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+    /**
+     * Get the names of the seeders.
+     */
+    get seeders(): string[];
+}
+
+declare class TransactionBeginning extends Event {
+    #private;
+    /**
+     * Create a new Transaction Beginning event instance.
+     */
+    constructor(connection: string);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+}
+
+declare class TransactionCommitted extends Event {
+    #private;
+    /**
+     * Create a new Transaction Committed event instance.
+     */
+    constructor(connection: string);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+}
+
+declare class TransactionRolledBack extends Event {
+    #private;
+    /**
+     * Create a new Transaction Rolled Back event instance.
+     */
+    constructor(connection: string, reason: unknown);
+    /**
+     * Get the name of the connection.
+     */
+    get connection(): string;
+    /**
+     * Get the reason the transaction was rolled back.
+     */
+    get reason(): unknown;
+}
+
+type DatabaseEvent = {
+    'database-blocked': DatabaseBlocked;
+    'migration-ended': MigrationEnded;
+    'migration-started': MigrationStarted;
+    'migrations-ended': MigrationsEnded;
+    'migrations-started': MigrationsStarted;
+    'no-pending-migrations': NoPendingMigrations;
+    'query': QueryExecuted;
+    'seeder-ended': SeederEnded;
+    'seeder-started': SeederStarted;
+    'seeding-ended': SeedingEnded;
+    'seeding-started': SeedingStarted;
+    'transaction-beginning': TransactionBeginning;
+    'transaction-committed': TransactionCommitted;
+    'transaction-rolled-back': TransactionRolledBack;
+};
+type DatabaseEventListener<K extends keyof DatabaseEvent> = (event: DatabaseEvent[K]) => void;
+
+declare class DatabaseManager {
+    #private;
+    /**
+     * Register the database configuration, replacing anything registered before.
+     */
+    static configure(config: DatabaseConfig): void;
+    /**
+     * Resolve a connection by name, or the default one.
+     */
+    static connection(name?: string): Connection;
+    /**
+     * Begin a query against a table on the default connection.
+     */
+    static table<T = Record<string, unknown>>(table: string): Builder<T>;
+    /**
+     * Run the callback inside a transaction on the default connection.
+     */
+    static transaction<R>(callback: (transaction: Transaction) => R | Promise<R>, options?: TransactionOptions): Promise<R>;
+    /**
+     * Run any pending migrations, returning the names of those this call ran.
+     */
+    static migrate(name: string): Promise<string[]>;
+    /**
+     * Run every registered seeder, returning their names.
+     */
+    static seed(name: string): Promise<string[]>;
+    /**
+     * Delete the database and replay every migration, optionally seeding afterwards.
+     */
+    static fresh(name: string, options?: FreshOptions): Promise<string[]>;
+    /**
+     * Get the state of every registered migration.
+     */
+    static status(name: string): Promise<MigrationStatus[]>;
+    /**
+     * Determine whether a table exists.
+     */
+    static hasTable(table: string, name?: string): Promise<boolean>;
+    /**
+     * Determine whether a table has a column.
+     */
+    static hasColumn(table: string, column: string, name?: string): Promise<boolean>;
+    /**
+     * Get the names of every table.
+     */
+    static getTables(name?: string): Promise<string[]>;
+    /**
+     * Get the columns of a table.
+     */
+    static getColumns(table: string, name?: string): Promise<ColumnSchema[]>;
+    /**
+     * Get the indexes of a table.
+     */
+    static getIndexes(table: string, name?: string): Promise<IndexSchema[]>;
+    /**
+     * Close a connection, leaving it registered so the next query reopens it.
+     */
+    static disconnect(name: string): void;
+    /**
+     * Close a connection and drop it, so the next resolve rebuilds it from configuration.
+     */
+    static purge(name: string): void;
+    /**
+     * Get how much storage this origin is using, and how much it may use.
+     */
+    static estimate(): Promise<StorageEstimate>;
+    /**
+     * Ask the browser not to evict this origin's storage under pressure.
+     */
+    static persist(): Promise<boolean>;
+    /**
+     * Determine whether this origin's storage is already exempt from eviction.
+     */
+    static persisted(): Promise<boolean>;
+    /**
+     * Register an event listener.
+     */
+    static listen<K extends keyof DatabaseEvent>(event: K, listener: DatabaseEventListener<K>, options?: ListenOptions): void;
+    /**
+     * Remove an event listener.
+     */
+    static forget<K extends keyof DatabaseEvent>(event: K, listener: DatabaseEventListener<K>): void;
+    /**
+     * Register a listener on the "query" event.
+     */
+    static onQueryExecuted(listener: (event: QueryExecuted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "transaction-beginning" event.
+     */
+    static onTransactionBeginning(listener: (event: TransactionBeginning) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "transaction-committed" event.
+     */
+    static onTransactionCommitted(listener: (event: TransactionCommitted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "transaction-rolled-back" event.
+     */
+    static onTransactionRolledBack(listener: (event: TransactionRolledBack) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "migrations-started" event.
+     */
+    static onMigrationsStarted(listener: (event: MigrationsStarted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "migration-started" event.
+     */
+    static onMigrationStarted(listener: (event: MigrationStarted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "migration-ended" event.
+     */
+    static onMigrationEnded(listener: (event: MigrationEnded) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "migrations-ended" event.
+     */
+    static onMigrationsEnded(listener: (event: MigrationsEnded) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "no-pending-migrations" event.
+     */
+    static onNoPendingMigrations(listener: (event: NoPendingMigrations) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "database-blocked" event.
+     */
+    static onDatabaseBlocked(listener: (event: DatabaseBlocked) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "seeding-started" event.
+     */
+    static onSeedingStarted(listener: (event: SeedingStarted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "seeder-started" event.
+     */
+    static onSeederStarted(listener: (event: SeederStarted) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "seeder-ended" event.
+     */
+    static onSeederEnded(listener: (event: SeederEnded) => void, options?: ListenOptions): void;
+    /**
+     * Register a listener on the "seeding-ended" event.
+     */
+    static onSeedingEnded(listener: (event: SeedingEnded) => void, options?: ListenOptions): void;
+    /**
+     * Start recording every query that runs.
+     */
+    static enableQueryLog(): void;
+    /**
+     * Stop recording queries.
+     */
+    static disableQueryLog(): void;
+    /**
+     * Get the recorded queries.
+     */
+    static getQueryLog(): QueryLogEntry[];
+    /**
+     * Discard the recorded queries.
+     */
+    static flushQueryLog(): void;
+    /**
+     * Determine whether queries are being recorded.
+     */
+    static logging(): boolean;
+}
+
+declare class Schema {
+    #private;
+    /**
+     * Get the table names the database layer reserves for itself.
+     */
+    static reserved(): string[];
+    /**
+     * Get a connection to read schema information from.
+     */
+    static connection(name?: string): Connection;
+    /**
+     * Determine whether a table exists.
+     */
+    static hasTable(table: string): Promise<boolean>;
+    /**
+     * Determine whether a table has a column.
+     */
+    static hasColumn(table: string, column: string): Promise<boolean>;
+    /**
+     * Get the names of every table.
+     */
+    static getTables(): Promise<string[]>;
+    /**
+     * Get the columns of a table.
+     */
+    static getColumns(table: string): Promise<ColumnSchema[]>;
+    /**
+     * Get the indexes of a table.
+     */
+    static getIndexes(table: string): Promise<IndexSchema[]>;
+    /**
+     * Create a table.
+     */
+    static create(table: string, callback: (table: Blueprint) => void): Promise<void>;
+    /**
+     * Alter a table.
+     */
+    static table(table: string, callback: (table: Blueprint) => void): Promise<void>;
+    /**
+     * Drop a table.
+     */
+    static drop(table: string): Promise<void>;
+    /**
+     * Drop a table, if it exists.
+     */
+    static dropIfExists(table: string): Promise<void>;
+    /**
+     * Rename a table, copying every record into the new one.
+     */
+    static rename(from: string, to: string): Promise<void>;
+}
+
+declare class CheckConstraintViolationException extends Error {
+    /**
+     * Create a new exception for a value the column does not accept.
+     */
+    constructor(table: string, column: string, value: unknown, accepted: string[]);
+}
+
+declare class ConnectionNotConfiguredException extends Error {
+    /**
+     * Create a new exception for an unconfigured connection.
+     */
+    constructor(connection: string);
+}
+
+declare class DatabaseBlockedException extends Error {
+    /**
+     * Create a new exception for a database blocked by another connection.
+     */
+    constructor(database: string);
+}
+
+declare class MigrationMismatchException extends Error {
+    /**
+     * Create a new exception for a migration list that diverged from what has run.
+     */
+    constructor(ran: string[], registered: string[]);
+}
+
+declare class MigrationTransactionClosedException extends Error {
+    /**
+     * Create a new exception for a migration that outlived its transaction.
+     */
+    constructor(migration: string);
+}
+
+declare class MultipleRecordsFoundException extends Error {
+    /**
+     * Create a new exception for a query that matched more records than it should.
+     */
+    constructor(table: string);
+}
+
+declare class NotNullConstraintViolationException extends Error {
+    /**
+     * Create a new exception for a null value in a non-nullable column.
+     */
+    constructor(table: string, column: string);
+}
+
+declare class QuotaExceededException extends Error {
+    /**
+     * Create a new exception for storage the browser refused to grant.
+     */
+    constructor(message?: string);
+}
+
+declare class RecordsNotFoundException extends Error {
+    /**
+     * Create a new exception for a query that matched no records.
+     */
+    constructor(message?: string);
+}
+
+declare class ReservedTableException extends Error {
+    /**
+     * Create a new exception for a table name reserved by the database layer.
+     */
+    constructor(table: string);
+}
+
+declare class SchemaException extends Error {
+    /**
+     * Create a new exception for a failed schema operation.
+     */
+    constructor(message?: string);
+}
+
+declare class TableNotFoundException extends Error {
+    /**
+     * Create a new exception for a missing table.
+     */
+    constructor(table: string);
+}
+
+declare class UniqueConstraintViolationException extends Error {
+    /**
+     * Create a new exception for a violated unique index.
+     */
+    constructor(table: string, index: string);
+}
+
+export { type Aggregated, type Aggregation, type Aggregations, Blueprint, Builder, CheckConstraintViolationException, ColumnDefinition, type ColumnSchema, type ColumnType, type Conjunction, Connection, type ConnectionConfig, ConnectionNotConfiguredException, type Constraint, DatabaseManager as DB, DatabaseBlocked, DatabaseBlockedException, type DatabaseConfig, type DatabaseEvent, type DatabaseEventListener, DatabaseManager, type DatePart, type Direction, type Enumerable, type FreshOptions, type Grouped, Grouping, type IndexSchema, Join, type JoinClause, type JoinCondition, type JoinType, type Key, type ListenOptions, Migration, type MigrationConstructor, MigrationEnded, MigrationMismatchException, MigrationStarted, type MigrationStatus, MigrationTransactionClosedException, MigrationsEnded, MigrationsStarted, MultipleRecordsFoundException, NoPendingMigrations, NotNullConstraintViolationException, type Operator, type Order, type Paginated, type Plan, type Projection, QueryExecuted, type QueryLogEntry, QuotaExceededException, RecordsNotFoundException, ReservedTableException, Schema, SchemaException, Seeder, type SeederConstructor, SeederEnded, SeederStarted, SeedingEnded, SeedingStarted, TableNotFoundException, type TableSchema, Transaction, TransactionBeginning, TransactionCommitted, type TransactionOptions, TransactionRolledBack, UniqueConstraintViolationException };