rado 0.1.62 → 0.1.63

package/dist/define/Fields.d.ts

@@ -1,13 +1,13 @@
-import { Column, PrimaryKey } from './Column';
-import { Expr } from './Expr';
-type ObjectUnion<T> = {
-    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
-};
-type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
-    [K in keyof Row]-?: Field<Row[K]>;
-} : never;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
-export {};
+import { Column, PrimaryKey } from './Column';
+import { Expr } from './Expr';
+type ObjectUnion<T> = {
+    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
+};
+type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
+type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
+type FieldsOf<Row> = Row extends Record<string, any> ? {
+    [K in keyof Row]-?: Field<Row[K]>;
+} : never;
+type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
+export {};

package/dist/define/Functions.d.ts

@@ -1,5 +1,5 @@
-import { Expr } from './Expr';
-export declare const Functions: Functions;
-export type Functions = {
-    [key: string]: (...args: Array<any>) => Expr<any>;
-};
+import { Expr } from './Expr';
+export declare const Functions: Functions;
+export type Functions = {
+    [key: string]: (...args: Array<any>) => Expr<any>;
+};

package/dist/define/Id.d.ts

@@ -1,3 +1,3 @@
-export type Id<T> = T extends {
-    id: any;
-} ? T['id'] : never;
+export type Id<T> = T extends {
+    id: any;
+} ? T['id'] : never;

package/dist/define/Index.d.ts

@@ -1,17 +1,17 @@
-import { Expr, ExprData } from './Expr';
-interface PartialIndexData {
-    on: Array<ExprData>;
-    unique?: boolean;
-    where?: ExprData;
-}
-export interface IndexData extends PartialIndexData {
-    name: string;
-}
-export declare class Index {
-    data: PartialIndexData;
-    constructor(data: PartialIndexData);
-    unique(): Index;
-    where(where: Expr<boolean>): Index;
-}
-export declare function index(...on: Array<Expr<any>>): Index;
-export {};
+import { Expr, ExprData } from './Expr';
+interface PartialIndexData {
+    on: Array<ExprData>;
+    unique?: boolean;
+    where?: ExprData;
+}
+export interface IndexData extends PartialIndexData {
+    name: string;
+}
+export declare class Index {
+    data: PartialIndexData;
+    constructor(data: PartialIndexData);
+    unique(): Index;
+    where(where: Expr<boolean>): Index;
+}
+export declare function index(...on: Array<Expr<any>>): Index;
+export {};

package/dist/define/Ops.d.ts

@@ -1,7 +1,7 @@
-import { Cursor } from './Cursor';
-import { Table } from './Table';
-export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
-export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
-export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
-export declare function create(...tables: Array<Table<any>>): Cursor.Batch;
+import { Cursor } from './Cursor';
+import { Table } from './Table';
+export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
+export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
+export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
+export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
+export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/define/OrderBy.d.ts

@@ -1,9 +1,9 @@
-import { ExprData } from './Expr';
-export declare enum OrderDirection {
-    Asc = "Asc",
-    Desc = "Desc"
-}
-export type OrderBy = {
-    expr: ExprData;
-    order: OrderDirection;
-};
+import { ExprData } from './Expr';
+export declare enum OrderDirection {
+    Asc = "Asc",
+    Desc = "Desc"
+}
+export type OrderBy = {
+    expr: ExprData;
+    order: OrderDirection;
+};

package/dist/define/Param.d.ts

@@ -1,15 +1,15 @@
-export declare enum ParamType {
-    Value = "Value",
-    Named = "Named"
-}
-export type ParamData = {
-    type: ParamType.Value;
-    value: any;
-} | {
-    type: ParamType.Named;
-    name: string;
-};
-export declare const ParamData: {
-    Value(value: any): ParamData;
-    Named(name: string): ParamData;
-};
+export declare enum ParamType {
+    Value = "Value",
+    Named = "Named"
+}
+export type ParamData = {
+    type: ParamType.Value;
+    value: any;
+} | {
+    type: ParamType.Named;
+    name: string;
+};
+export declare const ParamData: {
+    Value(value: any): ParamData;
+    Named(name: string): ParamData;
+};

package/dist/define/Query.d.ts

@@ -1,109 +1,109 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { IndexData } from './Index';
-import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
-        limit?: number;
-        offset?: number;
-        type: QueryType;
-        where?: ExprData;
-        orderBy?: Array<OrderBy>;
-        groupBy?: Array<ExprData>;
-        having?: ExprData;
-        selection?: ExprData;
-        singleResult?: boolean;
-        validate?: boolean;
-    }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
-        type: QueryType.Select;
-        selection: ExprData;
-        from: Target;
-    }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
-        type: QueryType.Update;
-        table: Schema;
-        set?: Record<string, any>;
-    }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
-        type: QueryType.Delete;
-        table: Schema;
-    }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
-        type: QueryType.CreateTable;
-        table: Schema;
-        ifNotExists?: boolean;
-    }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: IndexData;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
-        type: QueryType.Batch;
-        queries: Array<Query<any>>;
-    }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
-        Begin = "Begin",
-        Commit = "Commit",
-        Rollback = "Rollback"
-    }
-    interface Transaction extends QueryBase {
-        type: QueryType.Transaction;
-        id: string;
-        op: TransactionOperation;
-    }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
-        type: QueryType.Raw;
-        expectedReturn?: 'row' | 'rows';
-        strings: ReadonlyArray<string>;
-        params: Array<any>;
-    }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
-    interface AlterTable extends QueryBase {
-        type: QueryType.AlterTable;
-        table: Schema;
-        alterColumn?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { IndexData } from './Index';
+import { OrderBy } from './OrderBy';
+import { Schema } from './Schema';
+import { Target } from './Target';
+export declare enum QueryType {
+    Insert = "Insert",
+    Select = "Select",
+    Update = "Update",
+    Delete = "Delete",
+    CreateTable = "CreateTable",
+    CreateIndex = "CreateIndex",
+    DropIndex = "DropIndex",
+    AlterTable = "AlterTable",
+    Batch = "Batch",
+    Transaction = "Transaction",
+    Raw = "Raw"
+}
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
+export declare namespace Query {
+    interface QueryBase {
+        limit?: number;
+        offset?: number;
+        type: QueryType;
+        where?: ExprData;
+        orderBy?: Array<OrderBy>;
+        groupBy?: Array<ExprData>;
+        having?: ExprData;
+        selection?: ExprData;
+        singleResult?: boolean;
+        validate?: boolean;
+    }
+    interface Insert extends QueryBase {
+        type: QueryType.Insert;
+        into: Schema;
+        data: Array<any>;
+    }
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
+    interface Select extends QueryBase {
+        type: QueryType.Select;
+        selection: ExprData;
+        from: Target;
+    }
+    function Select(select: Omit<Select, 'type'>): Query.Select;
+    interface Update extends QueryBase {
+        type: QueryType.Update;
+        table: Schema;
+        set?: Record<string, any>;
+    }
+    function Update(update: Omit<Update, 'type'>): Query.Update;
+    interface Delete extends QueryBase {
+        type: QueryType.Delete;
+        table: Schema;
+    }
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
+    interface CreateTable extends QueryBase {
+        type: QueryType.CreateTable;
+        table: Schema;
+        ifNotExists?: boolean;
+    }
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface CreateIndex extends QueryBase {
+        type: QueryType.CreateIndex;
+        table: Schema;
+        index: IndexData;
+        ifNotExists?: boolean;
+    }
+    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
+    interface DropIndex extends QueryBase {
+        type: QueryType.DropIndex;
+        table: Schema;
+        name: string;
+        ifExists?: boolean;
+    }
+    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
+    interface Batch extends QueryBase {
+        type: QueryType.Batch;
+        queries: Array<Query<any>>;
+    }
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
+    enum TransactionOperation {
+        Begin = "Begin",
+        Commit = "Commit",
+        Rollback = "Rollback"
+    }
+    interface Transaction extends QueryBase {
+        type: QueryType.Transaction;
+        id: string;
+        op: TransactionOperation;
+    }
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
+    type RawReturn = 'row' | 'rows' | undefined;
+    interface Raw extends QueryBase {
+        type: QueryType.Raw;
+        expectedReturn?: 'row' | 'rows';
+        strings: ReadonlyArray<string>;
+        params: Array<any>;
+    }
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: ColumnData;
+        addColumn?: ColumnData;
+        dropColumn?: string;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
+}

package/dist/define/Schema.d.ts

@@ -1,18 +1,18 @@
-import { Formatter } from '../lib/Formatter';
-import { ColumnData } from './Column';
-import { IndexData } from './Index';
-import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}
+import { Formatter } from '../lib/Formatter';
+import { ColumnData } from './Column';
+import { IndexData } from './Index';
+import { Query } from './Query';
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, IndexData>;
+}
+export interface SchemaInstructions {
+    columns: Record<string, string>;
+    indexes: Record<string, string>;
+}
+export declare namespace Schema {
+    function create(schema: Schema): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
+}

package/dist/define/Selection.d.ts

@@ -1,20 +1,20 @@
-import type { Cursor } from './Cursor';
-import type { Expr } from './Expr';
-type SelectionBase = (() => any) | Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
-interface SelectionRecord extends Record<string, Selection> {
-}
-export type Selection = SelectionBase | SelectionRecord;
-export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
-    type Infer<T> = T extends {
-        [__tableType](): infer K;
-    } ? K : T extends {
-        [__cursorType](): infer K;
-    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T as T[K] extends () => any ? never : K]: Infer<T[K]>;
-    } : T extends () => any ? never : T;
-    type With<A, B> = Expr<Combine<A, B>>;
-    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
-}
-export {};
+import type { Cursor } from './Cursor';
+import type { Expr } from './Expr';
+type SelectionBase = (() => any) | Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
+interface SelectionRecord extends Record<string, Selection> {
+}
+export type Selection = SelectionBase | SelectionRecord;
+export declare namespace Selection {
+    const __tableType: unique symbol;
+    const __cursorType: unique symbol;
+    type Infer<T> = T extends {
+        [__tableType](): infer K;
+    } ? K : T extends {
+        [__cursorType](): infer K;
+    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
+        [K in keyof T as T[K] extends () => any ? never : K]: Infer<T[K]>;
+    } : T extends () => any ? never : T;
+    type With<A, B> = Expr<Combine<A, B>>;
+    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
+}
+export {};

package/dist/define/Table.d.ts

@@ -1,62 +1,62 @@
-import { Column, PrimaryKey } from './Column';
-import { Cursor } from './Cursor';
-import { EV, Expr } from './Expr';
-import { Fields } from './Fields';
-import { Index } from './Index';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
-    [Selection.__tableType](): Table.Normalize<T>;
-    constructor(schema: Schema);
-    fetch(id: EV<T extends {
-        id: Column.IsPrimary<infer V, any>;
-    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
-    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
-    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
-    delete(): Cursor.Delete;
-    createTable(): Cursor.CreateTable;
-    as(alias: string): this;
-    alias(): Record<string, this>;
-    get(name: string): Expr<any>;
-    toExpr(): Expr<Table.Normalize<T>>;
-    schema(): Schema;
-}
-export declare namespace Table {
-    type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: EV<U[P]>;
-    } : never;
-    type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
-    }[keyof T];
-    type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
-    }[keyof T];
-    type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
-    export type Normalize<T> = {
-        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
-    export {};
-}
-export type TableOptions<T, R> = {
-    name: string;
-    alias?: string;
-    columns: {
-        [K in keyof T]: Column<T[K]>;
-    };
-    indexes?: (this: Fields<T>) => Record<string, Index>;
-};
-export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
-export declare namespace table {
-    export type infer<T> = Table.Infer<T>;
-    type Extensions<T> = {
-        [key: string]: (this: T, ...args: any[]) => any;
-    };
-    export function extend<T extends Table<any>, E extends Extensions<T>>(target: T, extensions: E): T & E;
-    export {};
-}
+import { Column, PrimaryKey } from './Column';
+import { Cursor } from './Cursor';
+import { EV, Expr } from './Expr';
+import { Fields } from './Fields';
+import { Index } from './Index';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Update } from './Update';
+export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
+    [Selection.__tableType](): Table.Normalize<T>;
+    constructor(schema: Schema);
+    fetch(id: EV<T extends {
+        id: Column.IsPrimary<infer V, any>;
+    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
+    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
+    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
+    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
+    delete(): Cursor.Delete;
+    createTable(): Cursor.CreateTable;
+    as(alias: string): this;
+    alias(): Record<string, this>;
+    get(name: string): Expr<any>;
+    toExpr(): Expr<Table.Normalize<T>>;
+    schema(): Schema;
+}
+export declare namespace Table {
+    type Intersection<A, B> = A & B extends infer U ? {
+        [P in keyof U]: EV<U[P]>;
+    } : never;
+    type OptionalKeys<T> = {
+        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
+    }[keyof T];
+    type RequiredKeys<T> = {
+        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
+    }[keyof T];
+    type Optionals<T> = {
+        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
+    };
+    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
+    export type Normalize<T> = {
+        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
+    };
+    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
+    export {};
+}
+export type TableOptions<T, R> = {
+    name: string;
+    alias?: string;
+    columns: {
+        [K in keyof T]: Column<T[K]>;
+    };
+    indexes?: (this: Fields<T>) => Record<string, Index>;
+};
+export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
+export declare namespace table {
+    export type infer<T> = Table.Infer<T>;
+    type Extensions<T> = {
+        [key: string]: (this: T, ...args: any[]) => any;
+    };
+    export function extend<T extends Table<any>, E extends Extensions<T>>(target: T, extensions: E): T & E;
+    export {};
+}

package/dist/define/Target.d.ts

@@ -1,38 +1,38 @@
-import { ExprData } from './Expr';
-import { Query as QueryData } from './Query';
-import { Schema } from './Schema';
-export declare enum TargetType {
-    Expr = "Expr",
-    Query = "Query",
-    Table = "Table",
-    Join = "Join"
-}
-export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
-export declare namespace Target {
-    interface Expr {
-        type: TargetType.Expr;
-        expr: ExprData;
-        alias?: string;
-    }
-    function Expr(expr: ExprData, alias?: string): Expr;
-    interface Query {
-        type: TargetType.Query;
-        query: QueryData;
-        alias?: string;
-    }
-    function Query(query: QueryData, alias?: string): Query;
-    interface Table {
-        type: TargetType.Table;
-        table: Schema;
-    }
-    function Table(table: Schema): Table;
-    interface Join {
-        type: TargetType.Join;
-        left: Target;
-        right: Target;
-        joinType: 'left' | 'inner';
-        on: ExprData;
-    }
-    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): Schema | undefined;
-}
+import { ExprData } from './Expr';
+import { Query as QueryData } from './Query';
+import { Schema } from './Schema';
+export declare enum TargetType {
+    Expr = "Expr",
+    Query = "Query",
+    Table = "Table",
+    Join = "Join"
+}
+export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
+export declare namespace Target {
+    interface Expr {
+        type: TargetType.Expr;
+        expr: ExprData;
+        alias?: string;
+    }
+    function Expr(expr: ExprData, alias?: string): Expr;
+    interface Query {
+        type: TargetType.Query;
+        query: QueryData;
+        alias?: string;
+    }
+    function Query(query: QueryData, alias?: string): Query;
+    interface Table {
+        type: TargetType.Table;
+        table: Schema;
+    }
+    function Table(table: Schema): Table;
+    interface Join {
+        type: TargetType.Join;
+        left: Target;
+        right: Target;
+        joinType: 'left' | 'inner';
+        on: ExprData;
+    }
+    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
+    function source(from: Target): Schema | undefined;
+}