rado 1.0.15 → 1.2.0

package/dist/compat.d.ts

@@ -1,8 +1,8 @@
 import type { HasSql } from './core/Internal.js';
 import type { Sql } from './core/Sql.js';
-import type { Table, TableDefinition, TableFields, TableInsert, TableRow } from './core/Table.js';
-export type InferSelectModel<T> = T extends Table<infer Definition> ? TableRow<Definition> : never;
-export type InferInsertModel<T> = T extends Table<infer Definition> ? TableInsert<Definition> : never;
+import type { Table, TableDefinition, TableFields } from './core/Table.js';
+export type { InsertRow as InferInsertModel, SelectRow as InferSelectModel } from './core/Table.js';
 export type SQL<T = unknown> = Sql<T>;
 export type SQLWrapper<T = unknown> = HasSql<T>;
 export declare function getTableColumns<Definition extends TableDefinition>(table: Table<Definition>): TableFields<Definition>;
+export { Rollback as TransactionRollbackError } from './core/Database.js';

package/dist/compat.js

@@ -1,7 +1,9 @@
 // src/compat.ts
+import { Rollback } from "./core/Database.js";
 function getTableColumns(table) {
   return table;
 }
 export {
+  Rollback as TransactionRollbackError,
   getTableColumns
 };

package/dist/core/Builder.d.ts

@@ -1,18 +1,24 @@
-import { type HasQuery, type HasSql, type HasTarget, internalData } from './Internal.js';
+import { type HasSql, internalData } from './Internal.js';
 import type { IsPostgres, QueryMeta } from './MetaData.js';
-import type { QueryData } from './Query.js';
-import { type SelectionInput } from './Selection.js';
+import type { QueryData, SingleQuery } from './Queries.js';
+import type { SelectionInput, SelectionRow } from './Selection.js';
 import type { Table, TableDefinition } from './Table.js';
+import { type CTE } from './query/CTE.js';
 import { DeleteFrom } from './query/Delete.js';
 import { InsertInto } from './query/Insert.js';
-import type { WithSelection, WithoutSelection } from './query/Select.js';
-import type { UnionBase } from './query/Union.js';
+import type { DeleteQuery, FromGuard, FromQuery, FromRow, InsertQuery, QueryBase, SelectionQuery, UpdateQuery } from './query/Query.js';
+import type { UnionBase, WithSelection, WithoutSelection } from './query/Select.js';
 import { UpdateTable } from './query/Update.js';
 declare class BuilderBase<Meta extends QueryMeta> {
-    readonly [internalData]: QueryData<Meta>;
-    constructor(data?: QueryData<Meta>);
+    readonly [internalData]: QueryData<Meta> & QueryBase;
+    constructor(data?: QueryData<Meta> & QueryBase);
+    $query<Returning extends SelectionInput>(select: SelectionQuery<Returning>): SingleQuery<SelectionRow<Returning>, Meta>;
+    $query<const From extends FromGuard>(from: FromQuery<From>): SingleQuery<FromRow<From>, Meta>;
+    $query<Returning extends SelectionInput, Definition extends TableDefinition>(insert: InsertQuery<Returning, Definition>): SingleQuery<SelectionRow<Returning>, Meta>;
+    $query<Returning extends SelectionInput, Definition extends TableDefinition>(remove: DeleteQuery<Returning, Definition>): SingleQuery<SelectionRow<Returning>, Meta>;
+    $query<Returning extends SelectionInput, Definition extends TableDefinition>(update: UpdateQuery<Returning, Definition>): SingleQuery<SelectionRow<Returning>, Meta>;
     select(): WithoutSelection<Meta>;
-    select<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
+    select<Input extends SelectionInput>(select: 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>;
@@ -21,7 +27,6 @@ declare class BuilderBase<Meta extends QueryMeta> {
     insert<Definition extends TableDefinition>(into: Table<Definition>): InsertInto<Definition, Meta>;
     delete<Definition extends TableDefinition>(from: Table<Definition>): DeleteFrom<Definition, 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: UnionBase<Input, Meta>): CTE<Input>;

package/dist/core/Builder.js

@@ -1,73 +1,65 @@
 // src/core/Builder.ts
-import {
-  getData,
-  getQuery,
-  getSelection,
-  internalData,
-  internalQuery
-} from "./Internal.js";
-import { selection } from "./Selection.js";
-import { DeleteFrom } from "./query/Delete.js";
-import { InsertInto } from "./query/Insert.js";
+import { getData, internalData } from "./Internal.js";
+import { createCTE } from "./query/CTE.js";
+import { Delete, DeleteFrom } from "./query/Delete.js";
+import { Insert, InsertInto } from "./query/Insert.js";
 import { Select } from "./query/Select.js";
-import { UpdateTable } from "./query/Update.js";
+import { Update, UpdateTable } from "./query/Update.js";
 var BuilderBase = class {
   [internalData];
   constructor(data = {}) {
     this[internalData] = data;
   }
-  select(input) {
+  $query(query) {
+    const data = { ...getData(this), ...query };
+    if ("delete" in query) return new Delete(data);
+    if ("insert" in query) return new Insert(data);
+    if ("update" in query) return new Update(data);
+    return new Select(data);
+  }
+  select(select) {
     return new Select({
       ...getData(this),
-      select: input && selection(input)
+      select
     });
   }
-  selectDistinct(input) {
+  selectDistinct(select) {
     return new Select({
       ...getData(this),
-      select: input && selection(input),
+      select,
       distinct: true
     });
   }
-  selectDistinctOn(columns, input) {
+  selectDistinctOn(columns, select) {
     return new Select({
       ...getData(this),
-      select: input && selection(input),
+      select,
       distinctOn: columns
     });
   }
   update(table) {
-    return new UpdateTable({ ...getData(this), table });
+    return new UpdateTable({ ...getData(this), update: table });
   }
   insert(into) {
-    return new InsertInto({ ...getData(this), into });
+    return new InsertInto({ ...getData(this), insert: into });
   }
   delete(from) {
-    return new DeleteFrom({ ...getData(this), from });
+    return new DeleteFrom({ ...getData(this), delete: from });
   }
 };
 var Builder = class extends BuilderBase {
   $with(cteName) {
     return {
       as(query) {
-        const fields = getSelection(query).makeVirtual(cteName);
-        return Object.assign(fields, {
-          [internalQuery]: getQuery(query).nameSelf(cteName)
-        });
+        return createCTE(cteName, query);
       }
     };
   }
   with(...definitions) {
-    return new BuilderBase({
-      ...getData(this),
-      cte: { recursive: false, definitions }
-    });
+    return new BuilderBase({ ...getData(this), with: definitions });
   }
   withRecursive(...definitions) {
-    return new BuilderBase({
-      ...getData(this),
-      cte: { recursive: true, definitions }
-    });
+    return new BuilderBase({ ...getData(this), withRecursive: definitions });
   }
 };
 export {

package/dist/core/Column.d.ts

@@ -11,13 +11,12 @@ export interface ColumnData {
     notNull?: boolean;
     isUnique?: boolean;
     autoIncrement?: boolean;
-    $default?(): Sql;
     defaultValue?: Sql;
     references?(): FieldData;
-    onUpdate?: Sql;
-    onDelete?: Sql;
     mapFromDriverValue?(value: unknown, specs: DriverSpecs): unknown;
     mapToDriverValue?(value: unknown): unknown;
+    $default?(): Sql;
+    $onUpdate?(): Sql;
 }
 type WithoutNull<Value> = Exclude<Value, null>;
 export declare class Column<Value = unknown> {
@@ -26,9 +25,13 @@ export declare class Column<Value = unknown> {
     notNull(): RequiredColumn<Value>;
     $defaultFn(value: () => Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
     $default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
+    $onUpdateFn(fn: () => Input<Value>): Column<Value>;
+    $onUpdate(fn: () => Input<Value>): Column<Value>;
     default(value: Input<WithoutNull<Value>>): Column<WithoutNull<Value>>;
     defaultNow(): Column<WithoutNull<Value>>;
-    primaryKey(): Column<WithoutNull<Value>>;
+    primaryKey(options?: {
+        autoIncrement: boolean;
+    }): Column<WithoutNull<Value>>;
     unique(name?: string): Column<Value>;
     references(foreignField: Field | (() => Field)): Column<Value>;
     $type<T>(): Column<null extends Value ? T | null : T>;
@@ -46,4 +49,10 @@ export interface Columns {
     [key: string]: (...args: Array<Input<any>>) => Sql<any>;
 }
 export declare const column: Columns;
+export type ColumnArguments<Options> = [name?: string] | [options: Options] | [name: string, options: Options];
+export declare function columnConfig<Options>(args: ColumnArguments<Options>): {
+    name: string | undefined;
+    options: Options | undefined;
+};
+export declare function formatColumn(column: ColumnData): Sql;
 export {};

package/dist/core/Column.js

@@ -1,7 +1,8 @@
 // src/core/Column.ts
 import { getData, getField, internalData } from "./Internal.js";
 import { sql } from "./Sql.js";
-import { input } from "./expr/Input.js";
+import { callFunction } from "./expr/Functions.js";
+import { input, mapToColumn } from "./expr/Input.js";
 var Column = class _Column {
   [internalData];
   constructor(data) {
@@ -19,15 +20,22 @@ var Column = class _Column {
   $default(value) {
     return new _Column({
       ...getData(this),
-      $default() {
-        return input(value instanceof Function ? value() : value);
-      }
+      $default: () => mapToColumn(getData(this), value instanceof Function ? value() : value)
+    });
+  }
+  $onUpdateFn(fn) {
+    return this.$onUpdate(fn);
+  }
+  $onUpdate(fn) {
+    return new _Column({
+      ...getData(this),
+      $onUpdate: () => mapToColumn(getData(this), fn())
     });
   }
   default(value) {
     return new _Column({
       ...getData(this),
-      defaultValue: input(value).inlineValues()
+      defaultValue: input(value)
     });
   }
   defaultNow() {
@@ -36,8 +44,8 @@ var Column = class _Column {
       defaultValue: sql.unsafe("now()")
     });
   }
-  primaryKey() {
-    return new _Column({ ...getData(this), primary: true });
+  primaryKey(options) {
+    return new _Column({ ...getData(this), ...options, primary: true });
   }
   unique(name) {
     return new _Column({ ...getData(this), isUnique: true });
@@ -78,8 +86,35 @@ var column = new Proxy(createColumn, {
     };
   }
 });
+function columnConfig(args) {
+  if (typeof args[0] === "string")
+    return { name: args[0], options: args[1] };
+  return { name: void 0, options: args[0] };
+}
+function formatReferences(fields) {
+  return callFunction(
+    sql.identifier(fields[0].targetName),
+    fields.map((field) => sql.identifier(field.fieldName))
+  );
+}
+function formatColumn(column2) {
+  const references = column2.references && sql`references ${formatReferences([column2.references()])}`;
+  return sql.query(
+    column2.type,
+    {
+      primaryKey: column2.primary,
+      notNull: column2.notNull,
+      unique: column2.isUnique,
+      autoincrement: column2.autoIncrement
+    },
+    column2.defaultValue !== void 0 ? sql`default (${column2.defaultValue})`.inlineValues() : void 0,
+    references
+  );
+}
 export {
   Column,
   JsonColumn,
-  column
+  column,
+  columnConfig,
+  formatColumn
 };

package/dist/core/Constraint.d.ts

@@ -1,7 +1,10 @@
-import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.js';
+import { type HasConstraint, type HasData, internalConstraint, internalData } from './Internal.js';
 import { type Sql } from './Sql.js';
 import type { Field, FieldData } from './expr/Field.js';
-export interface UniqueConstraintData {
+export interface ConstraintData {
+    name?: string;
+}
+export interface UniqueConstraintData extends ConstraintData {
     fields: Array<FieldData>;
     nullsNotDistinct?: boolean;
 }
@@ -13,8 +16,8 @@ export declare class UniqueConstraint<TableName extends string = string> impleme
     nullsNotDistinct(): UniqueConstraint<TableName>;
     get [internalConstraint](): Sql;
 }
-export declare function unique(): UniqueConstraint;
-export interface PrimaryKeyConstraintData {
+export declare function unique(name?: string): UniqueConstraint;
+export interface PrimaryKeyConstraintData extends ConstraintData {
     fields: Array<FieldData>;
 }
 export declare class PrimaryKeyConstraint<TableName extends string = string> implements HasData<PrimaryKeyConstraintData>, HasConstraint {
@@ -24,8 +27,12 @@ export declare class PrimaryKeyConstraint<TableName extends string = string> imp
     constructor(data: PrimaryKeyConstraintData);
     get [internalConstraint](): Sql;
 }
+export declare function primaryKey<TableName extends string = string>(options: {
+    name?: string;
+    columns: Array<Field<unknown, TableName>>;
+}): PrimaryKeyConstraint<TableName>;
 export declare function primaryKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): PrimaryKeyConstraint<TableName>;
-export interface ForeignKeyConstraintData {
+export interface ForeignKeyConstraintData extends ConstraintData {
     fields: Array<FieldData>;
     references: Array<FieldData>;
 }
@@ -36,5 +43,9 @@ export declare class ForeignKeyConstraint<TableName extends string = string> imp
     references<ForeignTable extends string>(...fields: Array<Field<unknown, ForeignTable>>): ForeignKeyConstraint<TableName>;
     get [internalConstraint](): Sql;
 }
+export declare function foreignKey<TableName extends string = string>(options: {
+    name?: string;
+    columns: Array<Field<unknown, TableName>>;
+}): ForeignKeyConstraint<TableName>;
 export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
 export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/core/Constraint.js

@@ -30,8 +30,8 @@ var UniqueConstraint = class _UniqueConstraint {
     ]);
   }
 };
-function unique() {
-  return new UniqueConstraint({ fields: [] });
+function unique(name) {
+  return new UniqueConstraint({ name, fields: [] });
 }
 var PrimaryKeyConstraint = class {
   constructor(data) {
@@ -47,8 +47,13 @@ var PrimaryKeyConstraint = class {
     )})`;
   }
 };
-function primaryKey(...fields) {
-  return new PrimaryKeyConstraint({ fields: fields.map(getField) });
+function primaryKey(...args) {
+  if (args.length === 1 && "columns" in args[0])
+    return new PrimaryKeyConstraint({
+      name: args[0].name,
+      fields: args[0].columns.map(getField)
+    });
+  return new PrimaryKeyConstraint({ fields: args.map(getField) });
 }
 var ForeignKeyConstraint = class _ForeignKeyConstraint {
   [internalData];
@@ -72,9 +77,15 @@ var ForeignKeyConstraint = class _ForeignKeyConstraint {
     )})`;
   }
 };
-function foreignKey(...fields) {
+function foreignKey(...args) {
+  if (args.length === 1 && "columns" in args[0])
+    return new ForeignKeyConstraint({
+      name: args[0].name,
+      fields: args[0].columns.map(getField),
+      references: []
+    });
   return new ForeignKeyConstraint({
-    fields: fields.map(getField),
+    fields: args.map(getField),
     references: []
   });
 }

package/dist/core/Database.d.ts

@@ -4,9 +4,11 @@ import type { Diff } from './Diff.js';
 import type { Driver } from './Driver.js';
 import { type HasQuery, type HasResolver, type HasSql, type HasTable, internalResolver } from './Internal.js';
 import type { Async, Deliver, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
-import { QueryBatch } from './Query.js';
+import { BatchQuery } from './Queries.js';
 import { Resolver } from './Resolver.js';
+import { type Sql } from './Sql.js';
 import type { Table } from './Table.js';
+import type { SelectFirst } from './query/Select.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
     driver: Driver;
     dialect: Dialect;
@@ -17,14 +19,19 @@ export declare class Database<Meta extends QueryMeta = Either> extends Builder<M
     close(this: Database<Sync>): void;
     [Symbol.dispose](this: Database<Sync>): void;
     [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
-    create(...tables: Array<HasTable>): QueryBatch<unknown, Meta>;
-    drop(...tables: Array<HasTable>): QueryBatch<unknown, Meta>;
+    create(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
+    drop(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
+    run(input: HasSql): Deliver<Meta, void>;
+    get<Result extends Array<unknown>>(input: HasQuery<Result>): Deliver<Meta, Result[number]>;
+    get<Result>(input: HasSql<Result>): Deliver<Meta, Result>;
+    all<Result>(input: HasSql<Result>): Deliver<Meta, Array<Result>>;
     migrate(...tables: Array<Table>): Deliver<Meta, void>;
-    batch<Queries extends Array<HasSql | HasQuery>>(queries: Queries): QueryBatch<unknown, Meta>;
+    batch<Queries extends Array<HasSql | HasQuery>>(queries: Queries): BatchQuery<unknown, Meta>;
     execute(input: HasSql): Deliver<Meta, 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']]): Deliver<Meta, T>;
+    $count(source: Table | HasSql, condition?: HasSql<boolean>): SelectFirst<Sql<number>, Meta>;
 }
 export interface TransactionUniversalOptions {
     async?: boolean;

package/dist/core/Database.js

@@ -6,9 +6,10 @@ import {
   getTable,
   internalResolver
 } from "./Internal.js";
-import { QueryBatch } from "./Query.js";
+import { BatchQuery } from "./Queries.js";
 import { Resolver } from "./Resolver.js";
 import { sql } from "./Sql.js";
+import { count } from "./expr/Aggregate.js";
 var Database = class extends Builder {
   driver;
   dialect;
@@ -32,17 +33,29 @@ var Database = class extends Builder {
     return this.close();
   }
   create(...tables) {
-    return new QueryBatch(
+    return new BatchQuery(
       getResolver(this),
       tables.flatMap((table) => getTable(table).create())
     );
   }
   drop(...tables) {
-    return new QueryBatch(
+    return new BatchQuery(
       getResolver(this),
       tables.map((table) => getTable(table).drop())
     );
   }
+  run(input) {
+    const sql2 = this.dialect.inline(input);
+    return this.driver.exec(sql2);
+  }
+  get(input) {
+    const emitter = this.dialect.emit(input);
+    return this.driver.prepare(emitter.sql).get(emitter.bind());
+  }
+  all(input) {
+    const emitter = this.dialect.emit(input);
+    return this.driver.prepare(emitter.sql).all(emitter.bind());
+  }
   migrate(...tables) {
     const computeDiff = this.diff;
     return this.transaction(
@@ -55,7 +68,7 @@ var Database = class extends Builder {
     );
   }
   batch(queries) {
-    return new QueryBatch(getResolver(this), queries);
+    return new BatchQuery(getResolver(this), queries);
   }
   execute(input) {
     const emitter = this.dialect.emit(input);
@@ -71,6 +84,9 @@ var Database = class extends Builder {
       { async: run.constructor.name === "AsyncFunction", ...options }
     );
   }
+  $count(source, condition) {
+    return this.select(count()).from(source).where(condition).$first();
+  }
 };
 var Rollback = class extends Error {
   constructor(data) {

package/dist/core/Dialect.js

@@ -14,13 +14,13 @@ var Dialect = class {
   emit = (input) => {
     const sql = hasQuery(input) ? getQuery(input) : getSql(input);
     const emitter = new this.#createEmitter(this.runtime);
-    sql.emitTo(emitter);
+    sql.emit(emitter);
     return emitter;
   };
   inline = (input) => {
     const sql = hasQuery(input) ? getQuery(input) : getSql(input);
     const emitter = new this.#createEmitter(this.runtime);
-    sql.inlineValues().emitTo(emitter);
+    sql.inlineValues().emit(emitter);
     return emitter.sql;
   };
 };

package/dist/core/Driver.d.ts

@@ -1,7 +1,7 @@
 import type { TransactionUniversalOptions } from './Database.js';
 export type Driver = SyncDriver | AsyncDriver;
 export type Statement = SyncStatement | AsyncStatement;
-export interface BatchQuery {
+export interface BatchedQuery {
     sql: string;
     params: Array<unknown>;
     isSelection: boolean;
@@ -19,7 +19,7 @@ export interface SyncDriver extends DriverSpecs {
     exec(query: string): void;
     prepare(query: string, options?: PrepareOptions): SyncStatement;
     transaction<T>(run: (inner: SyncDriver) => T, options: TransactionUniversalOptions): T;
-    batch(queries: Array<BatchQuery>): Array<Array<unknown>>;
+    batch(queries: Array<BatchedQuery>): Array<Array<unknown>>;
 }
 export interface SyncStatement {
     all(params: Array<unknown>): Array<object>;
@@ -33,7 +33,7 @@ export interface AsyncDriver extends DriverSpecs {
     exec(query: string): Promise<void>;
     prepare(query: string, options?: PrepareOptions): AsyncStatement;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionUniversalOptions): Promise<T>;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
 }
 export interface AsyncStatement {
     all(params: Array<unknown>): Promise<Array<object>>;

package/dist/core/Emitter.d.ts

@@ -1,17 +1,9 @@
-import type { ColumnData } from './Column.js';
-import { type HasQuery, type HasTarget } from './Internal.js';
+import { type HasSql } from './Internal.js';
 import type { Runtime } from './MetaData.js';
 import { type Param } from './Param.js';
 import { Sql } from './Sql.js';
-import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
-import type { IncludeData } from './expr/Include.js';
-import { type JsonPath } from './expr/Json.js';
-import type { Delete } from './query/Delete.js';
-import type { Insert } from './query/Insert.js';
-import type { SelectData } from './query/Select.js';
-import type { UnionData } from './query/Union.js';
-import type { Update } from './query/Update.js';
+import type { JsonPath } from './expr/Json.js';
 export declare abstract class Emitter {
     #private;
     sql: string;
@@ -26,25 +18,11 @@ export declare abstract class Emitter {
     bind(inputs?: Record<string, unknown>): Array<unknown>;
     processValue(value: unknown): unknown;
     emitIdentifierOrSelf(value: string): void;
-    selfName?: string;
-    emitSelf({ name, inner }: {
-        name: string;
-        inner: Sql;
-    }): void;
     emitUnsafe(value: string): void;
+    emitSelf(inner: Sql, name: string): void;
+    inlineFields(inner: Sql, withTableName: boolean): void;
+    inlineValues(inner: Sql): void;
     emitField({ targetName, fieldName }: FieldData): void;
-    emitCreateTable(tableApi: TableApi): void;
-    emitColumn(column: ColumnData): void;
-    emitReferences(fields: Array<FieldData>): void;
-    emitDelete(deleteOp: Delete<unknown>): void;
-    emitInsert(insert: Insert<unknown>): void;
-    emitSelect({ select, cte, from, distinct, distinctOn, where, groupBy, orderBy, having, limit, offset }: SelectData): void;
-    emitUnion({ left, operator, right }: UnionData): void;
-    emitUpdate(update: Update<unknown>): void;
-    emitWith(cte: {
-        recursive: boolean;
-        definitions: Array<HasQuery & HasTarget>;
-    }): void;
-    emitInclude(data: IncludeData): void;
-    emitUniversal(runtimes: Partial<Record<Runtime | 'default', Sql>>): void;
+    emitValueOrInline(value: unknown): void;
+    emitUniversal(runtimes: Partial<Record<Runtime | 'default', HasSql>>): void;
 }