rado 1.0.0-preview.0 → 1.0.0-preview.1

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "rado",
-  "version": "1.0.0-preview.0",
+  "version": "1.0.0-preview.1",
   "license": "MIT",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.build.json && bun build.ts",
     "size": "esbuild src/index.ts --bundle --minify --format=esm --outdir=dist",
     "profile": "cross-env PROFILE=true tsx build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
-    "prepublishOnly": "bun run build",
+    "prepublishOnly": "rm -rf dist && bun run build",
     "cycles": "madge --warning --circular src/index.ts",
     "test:bun": "bun test",
     "test:node": "node --test-force-exit --test-concurrency=1 --import tsx --test \"**/*.test.ts\"",

package/dist/src/core/Builder.d.ts

@@ -1,36 +0,0 @@
-import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.ts';
-import type { IsPostgres, QueryMeta } from './MetaData.ts';
-import type { QueryData } from './Query.ts';
-import type { SelectionInput } from './Selection.ts';
-import type { Table, TableDefinition } from './Table.ts';
-import { Create } from './query/CreateTable.ts';
-import { DeleteFrom } from './query/Delete.ts';
-import { Drop } from './query/DropTable.ts';
-import { InsertInto } from './query/Insert.ts';
-import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.ts';
-import { UpdateTable } from './query/Update.ts';
-declare class BuilderBase<Meta extends QueryMeta> {
-    readonly [internalData]: QueryData<Meta>;
-    constructor(data: QueryData<Meta>);
-    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
-    dropTable(table: HasTable): Drop<Meta>;
-    select(): WithoutSelection<Meta>;
-    select<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
-    selectDistinct(): WithoutSelection<Meta>;
-    selectDistinct<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
-    selectDistinctOn(this: Builder<IsPostgres>, columns: Array<HasSql>): WithoutSelection<Meta>;
-    selectDistinctOn<Input extends SelectionInput>(this: Builder<IsPostgres>, columns: Array<HasSql>, selection: Input): WithSelection<Input, Meta>;
-    update<Definition extends TableDefinition>(table: Table<Definition>): UpdateTable<Definition, Meta>;
-    insert<Definition extends TableDefinition>(into: Table<Definition>): InsertInto<Definition, Meta>;
-    delete(from: HasTable): DeleteFrom<Meta>;
-}
-export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
-export declare class Builder<Meta extends QueryMeta> extends BuilderBase<Meta> {
-    $with(cteName: string): {
-        as<Input extends SelectionInput>(query: SelectBase<Input, Meta>): CTE<Input>;
-    };
-    with(...cte: Array<CTE>): BuilderBase<Meta>;
-    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
-    dropTable(table: HasTable): Drop<Meta>;
-}
-export {};

package/dist/src/core/Column.d.ts

@@ -1,38 +0,0 @@
-import type { HasColumn, HasSql } from './Internal.ts';
-import { internalColumn } from './Internal.ts';
-import type { Sql } from './Sql.ts';
-import type { Field, FieldData } from './expr/Field.ts';
-import { type Input } from './expr/Input.ts';
-export declare class ColumnData {
-    type: Sql;
-    name?: string;
-    json?: boolean;
-    primary?: boolean;
-    notNull?: boolean;
-    isUnique?: boolean;
-    autoIncrement?: boolean;
-    defaultValue?(): HasSql;
-    references?(): FieldData;
-    onUpdate?: HasSql;
-    onDelete?: HasSql;
-    mapFromDriverValue?(value: unknown): unknown;
-    mapToDriverValue?(value: unknown): unknown;
-}
-export declare class Column<Value = unknown> implements HasColumn {
-    readonly [internalColumn]: ColumnData;
-    constructor(data: ColumnData);
-    notNull(): RequiredColumn<NonNullable<Value>>;
-    default(value: Input<NonNullable<Value>> | (() => Input<NonNullable<Value>>)): Column<NonNullable<Value>>;
-    primaryKey(): Column<NonNullable<Value>>;
-    unique(name?: string): Column<Value>;
-    references(foreignField: Field | (() => Field)): Column<Value>;
-}
-export declare class JsonColumn<Value = unknown> extends Column<Value> {
-    private brand;
-    constructor(data: ColumnData);
-}
-declare const required: unique symbol;
-export interface RequiredColumn<Value = unknown> extends Column<Value> {
-    [required]: true;
-}
-export {};

package/dist/src/core/Constraint.d.ts

@@ -1,39 +0,0 @@
-import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.ts';
-import type { Field, FieldData } from './expr/Field.ts';
-export interface UniqueConstraintData {
-    fields: Array<FieldData>;
-    nullsNotDistinct?: boolean;
-}
-export declare class UniqueConstraint<TableName extends string = string> implements HasData<UniqueConstraintData>, HasConstraint {
-    private brand;
-    [internalData]: UniqueConstraintData;
-    constructor(data: UniqueConstraintData);
-    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): UniqueConstraint<TableName>;
-    nullsNotDistinct(): UniqueConstraint<string>;
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
-}
-export declare function unique(): UniqueConstraint<string>;
-export interface PrimaryKeyConstraintData {
-    fields: Array<FieldData>;
-}
-export declare class PrimaryKeyConstraint<TableName extends string = string> implements HasData<PrimaryKeyConstraintData>, HasConstraint {
-    data: PrimaryKeyConstraintData;
-    private brand;
-    [internalData]: PrimaryKeyConstraintData;
-    constructor(data: PrimaryKeyConstraintData);
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
-}
-export declare function primaryKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): PrimaryKeyConstraint<TableName>;
-export interface ForeignKeyConstraintData {
-    fields: Array<FieldData>;
-    references: Array<FieldData>;
-}
-export declare class ForeignKeyConstraint<TableName extends string = string> implements HasData<ForeignKeyConstraintData>, HasConstraint {
-    private brand;
-    [internalData]: ForeignKeyConstraintData;
-    constructor(data: ForeignKeyConstraintData);
-    references<ForeignTable extends string>(...fields: Array<Field<unknown, ForeignTable>>): ForeignKeyConstraint<TableName>;
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
-}
-export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
-export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/src/core/Database.d.ts

@@ -1,43 +0,0 @@
-import { Builder } from './Builder.ts';
-import type { Dialect } from './Dialect.ts';
-import type { Driver } from './Driver.ts';
-import { internalResolver, type HasResolver } from './Internal.ts';
-import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.ts';
-import { Resolver } from './Resolver.ts';
-export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
-    #private;
-    readonly [internalResolver]: Resolver<Meta>;
-    constructor(driver: Driver, dialect: Dialect, transactionDepth?: number);
-    close(this: Database<Async>): Promise<void>;
-    close(this: Database<Sync>): void;
-    [Symbol.dispose](this: Database<Sync>): void;
-    [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
-    transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
-    transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
-    transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): T | Promise<T>;
-}
-export interface TransactionOptions {
-    universal: never;
-    sqlite: {
-        behavior?: 'deferred' | 'immediate' | 'exclusive';
-    };
-    postgres: {
-        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
-        accessMode?: 'read only' | 'read write';
-        deferrable?: boolean;
-    };
-    mysql: {
-        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
-        accessMode?: 'read only' | 'read write';
-        withConsistentSnapshot?: boolean;
-    };
-}
-export declare class Rollback extends Error {
-}
-export declare class Transaction<Meta extends QueryMeta> extends Database<Meta> {
-    rollback(): never;
-}
-export declare class SyncDatabase<Dialect extends QueryDialect> extends Database<Sync<Dialect>> {
-}
-export declare class AsyncDatabase<Dialect extends QueryDialect> extends Database<Async<Dialect>> {
-}

package/dist/src/core/Dialect.d.ts

@@ -1,6 +0,0 @@
-import type { Emitter } from './Emitter.ts';
-import { type HasQuery, type HasSql } from './Internal.ts';
-export declare function dialect(createEmitter: {
-    new (): Emitter;
-}): (input: HasSql | HasQuery) => Emitter;
-export type Dialect = ReturnType<typeof dialect>;

package/dist/src/core/Driver.d.ts

@@ -1,28 +0,0 @@
-export type Driver = SyncDriver | AsyncDriver;
-export type Statement = SyncStatement | AsyncStatement;
-export interface SyncDriver {
-    close(): void;
-    exec(query: string): void;
-    prepare(query: string, name?: string): SyncStatement;
-    transaction<T>(run: (inner: SyncDriver) => T, options: unknown, depth: number): T;
-}
-export interface SyncStatement {
-    all(params: Array<unknown>): Array<object>;
-    run(params: Array<unknown>): void;
-    get(params: Array<unknown>): object | null;
-    values(params: Array<unknown>): Array<Array<unknown>>;
-    free(): void;
-}
-export interface AsyncDriver {
-    close(): Promise<void>;
-    exec(query: string): Promise<void>;
-    prepare(query: string, name?: string): AsyncStatement;
-    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: unknown, depth: number): Promise<T>;
-}
-export interface AsyncStatement {
-    all(params: Array<unknown>): Promise<Array<object>>;
-    run(params: Array<unknown>): Promise<void>;
-    get(params: Array<unknown>): Promise<object | null>;
-    values(params: Array<unknown>): Promise<Array<Array<unknown>>>;
-    free(): void;
-}

package/dist/src/core/Emitter.d.ts

@@ -1,35 +0,0 @@
-import type { ColumnData } from './Column.ts';
-import { type HasQuery, type HasTarget } from './Internal.ts';
-import { type Param } from './Param.ts';
-import type { FieldData } from './expr/Field.ts';
-import type { Create } from './query/CreateTable.ts';
-import type { Delete } from './query/Delete.ts';
-import type { Drop } from './query/DropTable.ts';
-import type { Insert } from './query/Insert.ts';
-import type { Select } from './query/Select.ts';
-import type { Union } from './query/Union.ts';
-import type { Update } from './query/Update.ts';
-export declare abstract class Emitter {
-    sql: string;
-    params: Array<Param>;
-    bind(inputs?: Record<string, unknown>): Array<unknown>;
-    abstract emitIdentifier(value: string): void;
-    abstract emitValue(value: unknown): void;
-    abstract emitInline(value: unknown): void;
-    abstract emitJsonPath(value: Array<number | string>): void;
-    abstract emitPlaceholder(value: string): void;
-    abstract emitDefaultValue(): void;
-    emitUnsafe(value: string): void;
-    emitField(field: FieldData): void;
-    emitCreateTable(create: Create): void;
-    emitDrop(drop: Drop): void;
-    emitColumn(column: ColumnData): void;
-    emitReferences(fields: Array<FieldData>): void;
-    emitDelete(deleteOp: Delete<unknown>): void;
-    emitInsert(insert: Insert<unknown>): void;
-    emitSelect(select: Select<unknown>): void;
-    emitUnion(union: Union<unknown>): void;
-    emitUpdate(update: Update<unknown>): void;
-    abstract emitIdColumn(): void;
-    emitWith(cte: Array<HasQuery & HasTarget>): void;
-}

package/dist/src/core/Index.d.ts

@@ -1,28 +0,0 @@
-import { internalData, type HasData, type HasSql } from './Internal.ts';
-import type { Field, FieldData } from './expr/Field.ts';
-export interface IndexData {
-    fields: Array<FieldData>;
-    unique?: boolean;
-    concurrently?: boolean;
-    only?: boolean;
-    using?: HasSql;
-    order?: 'asc' | 'desc';
-    nulls?: 'first' | 'last';
-    where?: HasSql;
-}
-export declare class Index<TableName extends string = string> implements HasData<IndexData> {
-    private brand;
-    [internalData]: IndexData;
-    constructor(data: IndexData);
-    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): Index<TableName>;
-    concurrently(): Index<string>;
-    only(): Index<string>;
-    using<Sql>(using: HasSql<Sql>): Index<string>;
-    asc(): Index<string>;
-    desc(): Index<string>;
-    nullsFirst(): Index<string>;
-    nullsLast(): Index<string>;
-    where(where: HasSql<boolean>): Index<string>;
-}
-export declare function index(): Index<string>;
-export declare function uniqueIndex(): Index<string>;

package/dist/src/core/Internal.d.ts

@@ -1,67 +0,0 @@
-import type { ColumnData } from './Column.ts';
-import type { QueryMeta } from './MetaData.ts';
-import type { Resolver } from './Resolver.ts';
-import type { Selection } from './Selection.ts';
-import type { Sql } from './Sql.ts';
-import type { TableApi, TableDefinition } from './Table.ts';
-import type { FieldData } from './expr/Field.ts';
-export declare const internalData: unique symbol;
-export declare const internalSql: unique symbol;
-export declare const internalSelection: unique symbol;
-export declare const internalTarget: unique symbol;
-export declare const internalQuery: unique symbol;
-export declare const internalTable: unique symbol;
-export declare const internalColumn: unique symbol;
-export declare const internalField: unique symbol;
-export declare const internalResolver: unique symbol;
-export declare const internalConstraint: unique symbol;
-export declare class HasData<Data> {
-    get [internalData](): Data;
-}
-export declare class HasSql<Value = unknown> {
-    get [internalSql](): Sql<Value>;
-}
-export declare class HasSelection {
-    get [internalSelection](): Selection;
-}
-export declare class HasTarget {
-    get [internalTarget](): Sql;
-}
-export declare class HasQuery {
-    get [internalQuery](): Sql;
-}
-export declare class HasTable<Definition extends TableDefinition = TableDefinition, Name extends string = string> {
-    get [internalTable](): TableApi<Definition, Name>;
-}
-export declare class HasColumn {
-    get [internalColumn](): ColumnData;
-}
-export declare class HasField {
-    get [internalField](): FieldData;
-}
-export declare class HasResolver<Meta extends QueryMeta = QueryMeta> {
-    get [internalResolver](): Resolver<Meta>;
-}
-export declare class HasConstraint {
-    get [internalConstraint](): Sql;
-}
-export declare const hasData: <Data>(obj: object) => obj is HasData<Data>;
-export declare const getData: <Data>(obj: HasData<Data>) => Data;
-export declare const hasSql: <Value>(obj: object) => obj is HasSql<Value>;
-export declare const getSql: <Value>(obj: HasSql<Value>) => Sql<Value>;
-export declare const hasSelection: (obj: object) => obj is HasSelection;
-export declare const getSelection: (obj: HasSelection) => Selection;
-export declare const hasTarget: (obj: object) => obj is HasTarget;
-export declare const getTarget: (obj: HasTarget) => Sql<unknown>;
-export declare const hasQuery: (obj: object) => obj is HasQuery;
-export declare const getQuery: (obj: HasQuery) => Sql<unknown>;
-export declare const hasTable: (obj: object) => obj is HasTable<TableDefinition, string>;
-export declare const getTable: (obj: HasTable) => TableApi<TableDefinition, string>;
-export declare const hasColumn: (obj: object) => obj is HasColumn;
-export declare const getColumn: (obj: HasColumn) => ColumnData;
-export declare const hasField: (obj: object) => obj is HasField;
-export declare const getField: (obj: HasField) => FieldData;
-export declare const hasResolver: <Meta extends QueryMeta>(obj: object) => obj is HasResolver<Meta>;
-export declare const getResolver: <Meta extends QueryMeta>(obj: HasResolver<Meta>) => Resolver<Meta>;
-export declare const hasConstraint: (obj: object) => obj is HasConstraint;
-export declare const getConstraint: (obj: HasConstraint) => Sql<unknown>;

package/dist/src/core/MetaData.d.ts

@@ -1,27 +0,0 @@
-export type QueryMode = 'sync' | 'async' | undefined;
-export type QueryDialect = 'universal' | 'sqlite' | 'mysql' | 'postgres';
-export interface QueryMeta {
-    mode: QueryMode;
-    dialect: QueryDialect;
-}
-export interface Sync<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
-    mode: 'sync';
-    dialect: Dialect;
-}
-export interface Async<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
-    mode: 'async';
-    dialect: Dialect;
-}
-export interface IsPostgres extends QueryMeta {
-    dialect: 'postgres';
-}
-export interface IsMysql extends QueryMeta {
-    dialect: 'mysql';
-}
-export interface IsSqlite extends QueryMeta {
-    dialect: 'sqlite';
-}
-export interface Either extends QueryMeta {
-    mode: 'sync' | 'async';
-    dialect: QueryDialect;
-}

package/dist/src/core/Param.d.ts

@@ -1,9 +0,0 @@
-export declare class NamedParam {
-    name: string;
-    constructor(name: string);
-}
-export declare class ValueParam {
-    value: unknown;
-    constructor(value: unknown);
-}
-export type Param = NamedParam | ValueParam;

package/dist/src/core/Query.d.ts

@@ -1,40 +0,0 @@
-import { internalData, internalQuery, type HasQuery, type HasResolver, type HasTarget } from './Internal.ts';
-import type { Async, QueryMeta, Sync } from './MetaData.ts';
-import type { PreparedStatement, Resolver } from './Resolver.ts';
-import type { Sql } from './Sql.ts';
-export declare class QueryData<Meta extends QueryMeta> {
-    resolver?: Resolver<Meta>;
-    cte?: Array<HasQuery & HasTarget>;
-}
-export declare abstract class Query<Result, Meta extends QueryMeta> implements PromiseLike<Array<Result>> {
-    #private;
-    readonly [internalData]: QueryData<Meta>;
-    abstract [internalQuery]: Sql;
-    constructor(data: QueryData<Meta>);
-    [Symbol.iterator](): Generator<Promise<unknown>, Array<Result>, unknown>;
-    prepare<Inputs extends Record<string, unknown>>(name: string): PreparedQuery<Result, Inputs, Meta>;
-    all(this: Query<Result, Sync>): Array<Result>;
-    all(this: Query<Result, Async>): Promise<Array<Result>>;
-    all(db: HasResolver<Sync> | Resolver<Sync>): Array<Result>;
-    all(db: HasResolver<Async> | Resolver<Async>): Promise<Array<Result>>;
-    get(this: Query<Result, Sync>): Result;
-    get(this: Query<Result, Async>): Promise<Result>;
-    get(db: HasResolver<Sync> | Resolver<Sync>): Result;
-    get(db: HasResolver<Async> | Resolver<Async>): Promise<Result>;
-    run(this: Query<Result, Sync>): void;
-    run(this: Query<Result, Async>): Promise<void>;
-    run(db: HasResolver<Sync> | Resolver<Sync>): void;
-    run(db: HasResolver<Async> | Resolver<Async>): Promise<void>;
-    then<TResult1 = Array<Result>, TResult2 = never>(this: Query<Result, Sync | Async>, onfulfilled?: ((value: Array<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(this: Query<Result, Async>, onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<Array<Result> | TResult>;
-    finally(this: Query<Result, Async>, onfinally?: (() => void) | undefined | null): Promise<Array<Result>>;
-}
-export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
-    all(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Array<Result>;
-    all(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Array<Result>>;
-    get(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Result;
-    get(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Result>;
-    run(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): void;
-    run(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<void>;
-    execute(inputs?: Inputs): Promise<Array<Result>>;
-}

package/dist/src/core/Resolver.d.ts

@@ -1,23 +0,0 @@
-import type { Dialect } from './Dialect.ts';
-import type { Driver, Statement } from './Driver.ts';
-import type { Emitter } from './Emitter.ts';
-import { type HasQuery } from './Internal.ts';
-import type { QueryMeta } from './MetaData.ts';
-export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
-    #private;
-    private brand;
-    constructor(driver: Driver, dialect: Dialect);
-    prepare(query: HasQuery, name: string): PreparedStatement<Meta>;
-}
-type RowMapper = ((values: Array<unknown>) => unknown) | undefined;
-export declare class PreparedStatement<Meta extends QueryMeta> {
-    #private;
-    private brand;
-    constructor(emitter: Emitter, stmt: Statement, mapRow: RowMapper);
-    all(inputs?: Record<string, unknown>): Array<unknown> | Promise<Array<unknown>>;
-    get(inputs?: Record<string, unknown>): unknown | Promise<unknown>;
-    run(inputs?: Record<string, unknown>): unknown;
-    execute(inputs?: Record<string, unknown>): Promise<unknown>;
-    free(): void;
-}
-export {};

package/dist/src/core/Schema.d.ts

@@ -1,4 +0,0 @@
-import { type Table, type TableConfig, type TableDefinition } from './Table.ts';
-export declare function schema<SchemaName extends string>(schemaName: SchemaName): {
-    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: ((self: Table<Definition>) => TableConfig<`${SchemaName}.${TableName}`>) | undefined): Table<Definition, `${SchemaName}.${TableName}`>;
-};

package/dist/src/core/Selection.d.ts

@@ -1,27 +0,0 @@
-import { internalSql, type HasSql, type HasTable } from './Internal.ts';
-import { type Sql } from './Sql.ts';
-import type { Table, TableRow } from './Table.ts';
-import type { Expand } from './Types.ts';
-declare const nullable: unique symbol;
-export interface SelectionRecord extends Record<string, SelectionInput> {
-}
-export type IsNullable = {
-    [nullable]: true;
-};
-export type MakeNullable<T> = Expand<{
-    [K in keyof T]: T[K] & IsNullable;
-}>;
-export type SelectionInput = HasSql | HasTable | SelectionRecord;
-export type RowOfRecord<Input> = Expand<{
-    [Key in keyof Input as Key extends string ? Key : never]: SelectionRow<Input[Key]>;
-}>;
-export type SelectionRow<Input> = Input extends HasSql<infer Value> ? Value : Input extends IsNullable ? RowOfRecord<Input> | null : Input extends SelectionRecord ? RowOfRecord<Input> : Input extends Table<infer Definition> ? TableRow<Definition> : never;
-export declare class Selection implements HasSql {
-    #private;
-    constructor(input: SelectionInput, nullable: Set<string>);
-    makeVirtual(name: string): SelectionRecord | HasSql<unknown> | HasTable<import("./Table.ts").TableDefinition, string>;
-    mapRow: (values: Array<unknown>) => unknown;
-    get [internalSql](): Sql<unknown>;
-}
-export declare function selection(input: SelectionInput, nullable?: Set<string>): Selection;
-export {};

package/dist/src/core/Sql.d.ts

@@ -1,49 +0,0 @@
-import type { Emitter } from './Emitter.ts';
-import { internalSql, type HasSql } from './Internal.ts';
-import type { FieldData } from './expr/Field.ts';
-type EmitMethods = {
-    [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
-};
-declare class Chunk<Type = keyof EmitMethods, Inner = unknown> {
-    type: Type;
-    inner: Inner;
-    constructor(type: Type, inner: Inner);
-}
-export type Decoder<T> = ((value: unknown) => T) | {
-    mapFromDriverValue?(value: unknown): T;
-};
-export declare class Sql<Value = unknown> implements HasSql<Value> {
-    #private;
-    private brand;
-    alias?: string;
-    mapFromDriverValue?: (input: unknown) => Value;
-    readonly [internalSql]: this;
-    constructor(chunks?: Array<Chunk>);
-    as(name: string): Sql<Value>;
-    mapWith<T = Value>(decoder: Decoder<T>): Sql<T>;
-    chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql<Value>;
-    unsafe(sql: string): Sql<Value>;
-    field(field: FieldData): Sql<Value>;
-    add(sql: HasSql): Sql<Value>;
-    value(value: unknown): Sql<Value>;
-    inline(value: unknown): Sql<Value>;
-    jsonPath(path: Array<string | number>): Sql<Value>;
-    placeholder(name: string): Sql<Value>;
-    identifier(identifier: string): Sql<Value>;
-    inlineFields(withTableName: boolean): Sql<Value>;
-    emit(emitter: Emitter): void;
-}
-export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql>): Sql<T>;
-export declare namespace sql {
-    function empty<T>(): Sql<T>;
-    function unsafe<T>(directSql: string): Sql<T>;
-    function value<T>(value: T): Sql<T>;
-    function inline<T>(value: T): Sql<T>;
-    function placeholder<T>(name: string): Sql<T>;
-    function identifier<T>(identifier: string): Sql<T>;
-    function field<T>(field: FieldData): Sql<T>;
-    function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
-    function query(ast: Record<string, HasSql | undefined>): Sql;
-    function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;
-}
-export {};

package/dist/src/core/Table.d.ts

@@ -1,56 +0,0 @@
-import type { Column, JsonColumn, RequiredColumn } from './Column.ts';
-import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.ts';
-import type { Index } from './Index.ts';
-import { type HasSql, type HasTable, type HasTarget } from './Internal.ts';
-import { type Sql } from './Sql.ts';
-import { type JsonExpr } from './expr/Conditions.ts';
-import { Field } from './expr/Field.ts';
-import type { Input } from './expr/Input.ts';
-export type TableDefinition = {
-    [name: string]: Column;
-};
-declare class TableData {
-    name: string;
-    alias?: string;
-    schemaName?: string;
-    columns: TableDefinition;
-    config?: TableConfig;
-}
-export declare class TableApi<Definition extends TableDefinition = TableDefinition, Name extends string = string> extends TableData {
-    private brand;
-    get aliased(): string;
-    target(): Sql;
-    createDefinition(): Sql;
-    listColumns(): Sql;
-    fields(): Record<string, HasSql>;
-}
-export type Table<Definition extends TableDefinition = TableDefinition, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasTarget;
-export type TableFields<Definition extends TableDefinition, TableName extends string = string> = {
-    [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T> ? Field<T, TableName> : never;
-};
-export type TableRow<Definition extends TableDefinition> = {
-    [K in keyof Definition]: Definition[K] extends Column<infer T> ? T : never;
-} & {};
-type IsReq<Col> = Col extends RequiredColumn ? true : false;
-type Required<D> = {
-    [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K];
-};
-type Optional<D> = {
-    [K in keyof D as false extends IsReq<D[K]> ? K : never]: D[K];
-};
-type RequiredInput<D> = {
-    readonly [K in keyof Required<D>]: D[K] extends Column<infer V> ? Input<V> : never;
-};
-type OptionalInput<D> = {
-    readonly [K in keyof Optional<D>]?: D[K] extends Column<infer V> ? Input<V> : never;
-};
-export type TableInsert<Definition extends TableDefinition> = RequiredInput<Definition> & OptionalInput<Definition>;
-export type TableUpdate<Definition extends TableDefinition> = {
-    readonly [K in keyof Definition]?: Definition[K] extends Column<infer T> ? Input<T> : never;
-};
-export type TableConfigSetting<Name extends string> = UniqueConstraint<Name> | PrimaryKeyConstraint<Name> | ForeignKeyConstraint<Name> | Index<Name>;
-export interface TableConfig<Name extends string = string> extends Record<string, TableConfigSetting<Name>> {
-}
-export declare function table<Definition extends TableDefinition, Name extends string>(name: Name, columns: Definition, config?: (self: Table<Definition, Name>) => TableConfig<Name>, schemaName?: string): Table<Definition, Name>;
-export declare function alias<Definition extends TableDefinition, Alias extends string>(table: Table<Definition>, alias: Alias): Table<Definition, Alias>;
-export {};

package/dist/src/core/Types.d.ts

@@ -1,3 +0,0 @@
-export type Expand<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/src/core/Virtual.d.ts

@@ -1,2 +0,0 @@
-import type { SelectionInput } from './Selection.ts';
-export declare function virtual<Input extends SelectionInput>(alias: string, source?: Input): Input;

package/dist/src/core/expr/Aggregate.d.ts

@@ -1,10 +0,0 @@
-import { type HasSql } from '../Internal.ts';
-import { type Sql } from '../Sql.ts';
-export declare function count(input?: HasSql): Sql<number>;
-export declare function countDistinct(input: HasSql): Sql<number>;
-export declare function avg(input: HasSql): Sql<string | null>;
-export declare function avgDistinct(input: HasSql): Sql<string | null>;
-export declare function sum(input: HasSql): HasSql<string | null>;
-export declare function sumDistinct(input: HasSql): HasSql<string | null>;
-export declare function max<T>(input: HasSql<T>): Sql<T>;
-export declare function min<T>(input: HasSql<T>): Sql<T>;