rado 1.0.14 → 1.2.0

package/dist/core/query/Update.js

@@ -2,41 +2,41 @@
 import {
   getData,
   getTable,
-  hasSql,
   internalData,
   internalQuery,
   internalSelection
 } from "../Internal.js";
-import { Query } from "../Query.js";
+import { SingleQuery } from "../Queries.js";
 import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
 import { and } from "../expr/Conditions.js";
-import { input } from "../expr/Input.js";
-var Update = class extends Query {
+import { mapToColumn } from "../expr/Input.js";
+import { formatCTE } from "./CTE.js";
+import { formatModifiers } from "./Shared.js";
+var Update = class _Update extends SingleQuery {
   [internalData];
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = selection(data.returning);
   }
   get [internalQuery]() {
-    return sql.chunk("emitUpdate", this);
+    return updateQuery(getData(this));
+  }
+  limit(limit) {
+    return new _Update({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Update({ ...getData(this), offset });
+  }
+  orderBy(...orderBy) {
+    return new _Update({ ...getData(this), orderBy });
   }
 };
 var UpdateTable = class _UpdateTable extends Update {
-  set(values) {
-    const { table } = getData(this);
-    const set = sql.join(
-      Object.entries(values).map(([key, value]) => {
-        const column = getTable(table).columns[key];
-        const { mapToDriverValue } = getData(column);
-        const expr = value && typeof value === "object" && hasSql(value) ? value : input(mapToDriverValue?.(value) ?? value);
-        return sql`${sql.identifier(key)} = ${expr}`;
-      }),
-      sql`, `
-    );
+  set(set) {
     return new _UpdateTable({ ...getData(this), set });
   }
   where(...where) {
@@ -47,13 +47,42 @@ var UpdateTable = class _UpdateTable extends Update {
   }
   returning(returning) {
     const data = getData(this);
-    return new Update({
-      ...data,
-      returning: returning ? selection(returning) : selection.table(data.table)
-    });
+    return new Update({ ...data, returning: returning ?? data.update });
   }
 };
+function updateQuery(query) {
+  const { update: table, set: values, where, returning } = query;
+  const tableApi = getTable(table);
+  if (!values) throw new Error("Update values are required");
+  const set = sql.join(
+    Object.entries(tableApi.columns).map(([key, column]) => {
+      const columnApi = getData(column);
+      const { name, $onUpdate } = columnApi;
+      let expr;
+      if (!(key in values)) {
+        if ($onUpdate) expr = $onUpdate();
+        else return;
+      } else {
+        expr = mapToColumn(columnApi, values[key]);
+      }
+      const fieldName = name ?? key;
+      return sql`${sql.identifier(fieldName)} = ${expr}`;
+    }),
+    sql`, `
+  );
+  return sql.query(
+    formatCTE(query),
+    {
+      update: sql.identifier(tableApi.name),
+      set,
+      where,
+      returning: returning && selection(returning)
+    },
+    formatModifiers(query)
+  ).inlineFields(false);
+}
 export {
   Update,
-  UpdateTable
+  UpdateTable,
+  updateQuery
 };

package/dist/driver/d1.d.ts

@@ -1,5 +1,5 @@
 import { AsyncDatabase } from '../core/Database.js';
-import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+import type { AsyncDriver, AsyncStatement, BatchedQuery, PrepareOptions } from '../core/Driver.js';
 type Client = D1Database;
 declare class PreparedStatement implements AsyncStatement {
     private stmt;
@@ -19,7 +19,7 @@ export declare class D1Driver implements AsyncDriver {
     exec(query: string): Promise<void>;
     prepare(sql: string, options: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(): Promise<T>;
 }
 export declare function connect(client: Client): AsyncDatabase<'sqlite'>;

package/dist/driver/libsql.d.ts

@@ -1,6 +1,6 @@
 import type { Client, InValue, Transaction } from '@libsql/client';
 import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
-import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+import type { AsyncDriver, AsyncStatement, BatchedQuery, PrepareOptions } from '../core/Driver.js';
 type Queryable = Client | Transaction;
 declare class PreparedStatement implements AsyncStatement {
     private client;
@@ -21,7 +21,7 @@ export declare class LibSQLClient implements AsyncDriver {
     exec(query: string): Promise<void>;
     prepare(sql: string, options: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['sqlite']): Promise<T>;
 }
 export declare function connect(client: Client): AsyncDatabase<'sqlite'>;

package/dist/driver/mysql2.d.ts

@@ -1,7 +1,7 @@
 import type { Connection } from 'mysql2';
 import type { Pool, PoolConnection, Connection as PromiseConnection } from 'mysql2/promise';
 import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
-import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+import type { AsyncDriver, AsyncStatement, BatchedQuery, PrepareOptions } from '../core/Driver.js';
 type Queryable = PromiseConnection | Pool | PoolConnection;
 declare class PreparedStatement implements AsyncStatement {
     #private;
@@ -24,7 +24,7 @@ export declare class Mysql2Driver implements AsyncDriver {
     exec(query: string): Promise<void>;
     prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['mysql']): Promise<T>;
 }
 export declare function connect(client: Queryable | Connection): AsyncDatabase<'mysql'>;

package/dist/driver/pg.d.ts

@@ -1,6 +1,6 @@
 import type { Client, Pool, PoolClient } from 'pg';
 import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
-import type { AsyncDriver, AsyncStatement, BatchQuery, PrepareOptions } from '../core/Driver.js';
+import type { AsyncDriver, AsyncStatement, BatchedQuery, PrepareOptions } from '../core/Driver.js';
 type Queryable = Client | Pool | PoolClient;
 declare class PreparedStatement implements AsyncStatement {
     private client;
@@ -22,7 +22,7 @@ export declare class PgDriver implements AsyncDriver {
     exec(query: string): Promise<void>;
     prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres']): Promise<T>;
 }
 export declare function connect(client: Queryable): AsyncDatabase<'postgres'>;

package/dist/driver/pglite.d.ts

@@ -1,6 +1,6 @@
 import type { PGlite, Transaction } from '@electric-sql/pglite';
 import { AsyncDatabase, type TransactionOptions } from '../core/Database.js';
-import type { AsyncDriver, AsyncStatement, BatchQuery } from '../core/Driver.js';
+import type { AsyncDriver, AsyncStatement, BatchedQuery } from '../core/Driver.js';
 type Queryable = PGlite | Transaction;
 declare class PreparedStatement implements AsyncStatement {
     private client;
@@ -21,7 +21,7 @@ export declare class PGliteDriver implements AsyncDriver {
     exec(query: string): Promise<void>;
     close(): Promise<void>;
     prepare(sql: string): PreparedStatement;
-    batch(queries: Array<BatchQuery>): Promise<Array<Array<unknown>>>;
+    batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres']): Promise<T>;
 }
 export declare function connect(db: PGlite): AsyncDatabase<'postgres'>;

package/dist/index.d.ts

@@ -4,17 +4,17 @@ export * from './core/Column.js';
 export * from './core/Constraint.js';
 export * from './core/Database.js';
 export * from './core/Driver.js';
-export * from './core/Index.js';
-export * from './core/Internal.js';
-export * from './core/Query.js';
-export * from './core/Selection.js';
-export * from './core/Sql.js';
-export * from './core/Table.js';
 export * from './core/expr/Aggregate.js';
 export * from './core/expr/Conditions.js';
 export * from './core/expr/Include.js';
+export * from './core/Index.js';
+export * from './core/Internal.js';
+export * from './core/Queries.js';
+export * from './core/query/CTE.js';
 export * from './core/query/Delete.js';
 export * from './core/query/Insert.js';
 export * from './core/query/Select.js';
-export * from './core/query/Union.js';
 export * from './core/query/Update.js';
+export * from './core/Selection.js';
+export * from './core/Sql.js';
+export * from './core/Table.js';

package/dist/index.js

@@ -5,17 +5,17 @@ export * from "./core/Column.js";
 export * from "./core/Constraint.js";
 export * from "./core/Database.js";
 export * from "./core/Driver.js";
-export * from "./core/Index.js";
-export * from "./core/Internal.js";
-export * from "./core/Query.js";
-export * from "./core/Selection.js";
-export * from "./core/Sql.js";
-export * from "./core/Table.js";
 export * from "./core/expr/Aggregate.js";
 export * from "./core/expr/Conditions.js";
 export * from "./core/expr/Include.js";
+export * from "./core/Index.js";
+export * from "./core/Internal.js";
+export * from "./core/Queries.js";
+export * from "./core/query/CTE.js";
 export * from "./core/query/Delete.js";
 export * from "./core/query/Insert.js";
 export * from "./core/query/Select.js";
-export * from "./core/query/Union.js";
 export * from "./core/query/Update.js";
+export * from "./core/Selection.js";
+export * from "./core/Sql.js";
+export * from "./core/Table.js";

package/dist/mysql/columns.d.ts

@@ -1,71 +1,71 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, type ColumnArguments, JsonColumn } from '../core/Column.js';
 type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
-export declare function bigint(name: string | undefined, options: {
+export declare function bigint(...args: ColumnArguments<{
     mode: 'number';
     unsigned?: boolean;
-}): Column<number | null>;
-export declare function bigint(name?: string, options?: {
+}>): Column<number | null>;
+export declare function bigint(...args: ColumnArguments<{
     unsigned?: boolean;
-}): Column<bigint | null>;
-export declare function binary(name?: string, options?: {
+}>): Column<bigint | null>;
+export declare function binary(...args: ColumnArguments<{
     length?: number;
-}): Column<Uint8Array | null>;
+}>): Column<Uint8Array | null>;
 export declare function boolean(name?: string): Column<boolean | null>;
 export declare function blob(name?: string): Column<Uint8Array | null>;
-export declare function char(name?: string, options?: {
-    length: number;
-}): Column<string | null>;
-export declare function date(name?: string, options?: {
+export declare function char(...args: ColumnArguments<{
+    length?: number;
+}>): Column<string | null>;
+export declare function date(...args: ColumnArguments<{
     mode: 'string';
-}): Column<string | null>;
-export declare function date(name: string | undefined, options: {
+}>): Column<string | null>;
+export declare function date(...args: ColumnArguments<{
     mode: 'date';
-}): Column<Date | null>;
-export declare function datetime(name?: string, options?: {
+}>): Column<Date | null>;
+export declare function datetime(...args: ColumnArguments<{
     fsp?: Precision;
-}): Column<Date | null>;
-export declare function datetime(name: string | undefined, options: {
+}>): Column<Date | null>;
+export declare function datetime(...args: ColumnArguments<{
     mode: 'string';
     fsp?: Precision;
-}): Column<string | null>;
-export declare function decimal(name: string | undefined, options: {
+}>): Column<string | null>;
+export declare function decimal(...args: ColumnArguments<{
     precision?: number;
     scale?: number;
-}): Column<number | null>;
+}>): Column<number | null>;
 export declare function float(name?: string): Column<number | null>;
 export declare function integer(name?: string): Column<number | null>;
 export declare const int: typeof integer;
 export declare function json<T>(name?: string): JsonColumn<T | null>;
-export declare function mediumint(name?: string, options?: {
+export declare function mediumint(...args: ColumnArguments<{
     unsigned?: boolean;
-}): Column<number | null>;
+}>): Column<number | null>;
 export declare function real(name?: string): Column<number | null>;
 export declare function serial(name?: string): Column<number | null>;
-export declare function smallint(name?: string, options?: {
+export declare function smallint(...args: ColumnArguments<{
     unsigned?: boolean;
-}): Column<number | null>;
+}>): Column<number | null>;
 export declare function text(name?: string): Column<string | null>;
 export declare function tinytext(name?: string): Column<string | null>;
 export declare function mediumtext(name?: string): Column<string | null>;
 export declare function longtext(name?: string): Column<string | null>;
-export declare function time(name?: string, options?: {
+export declare function time(...args: ColumnArguments<{
     fsp?: Precision;
-}): Column<string | null>;
-export declare function timestamp(name: string | undefined, options?: {
+}>): Column<string | null>;
+export declare function timestamp(...args: ColumnArguments<{
     fsp?: Precision;
-}): Column<Date | null>;
-export declare function timestamp(name?: string, options?: {
+}>): Column<Date | null>;
+export declare function timestamp(...args: ColumnArguments<{
     mode: 'string';
     fsp?: Precision;
-}): Column<string | null>;
-export declare function tinyint(name?: string, options?: {
+}>): Column<string | null>;
+export declare function tinyint(...args: ColumnArguments<{
     unsigned?: boolean;
-}): Column<number | null>;
-export declare function varbinary(name?: string, options?: {
+}>): Column<number | null>;
+export declare function varbinary(...args: ColumnArguments<{
+    length?: number;
+}>): Column<Uint8Array | null>;
+export declare function varchar(...args: ColumnArguments<{
     length?: number;
-}): Column<Uint8Array | null>;
-export declare function varchar(name?: string, options?: {
-    length: number;
-}): Column<string | null>;
+}>): Column<string | null>;
 export declare function year(name?: string): Column<number | null>;
 export {};

package/dist/mysql/columns.js

@@ -1,13 +1,19 @@
 // src/mysql/columns.ts
-import { JsonColumn, column } from "../core/Column.js";
-function bigint(name, options) {
+import {
+  JsonColumn,
+  column,
+  columnConfig
+} from "../core/Column.js";
+function bigint(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column[options?.unsigned ? "bigint unsigned" : "bigint"](),
     mapFromDriverValue: options?.mode === "number" ? Number : BigInt
   });
 }
-function binary(name, options) {
+function binary(...args) {
+  const { name, options } = columnConfig(args);
   return column({ name, type: column.binary(options?.length) });
 }
 function boolean(name) {
@@ -16,10 +22,12 @@ function boolean(name) {
 function blob(name) {
   return column({ name, type: column.blob() });
 }
-function char(name, options) {
+function char(...args) {
+  const { name, options } = columnConfig(args);
   return column({ name, type: column.char(options?.length) });
 }
-function date(name, options) {
+function date(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column.date(),
@@ -31,7 +39,8 @@ function date(name, options) {
     }
   });
 }
-function datetime(name, options) {
+function datetime(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column.datetime(options?.fsp),
@@ -43,10 +52,11 @@ function datetime(name, options) {
     }
   });
 }
-function decimal(name, options) {
+function decimal(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
-    type: column.decimal(options.precision, options.scale)
+    type: column.decimal(options?.precision, options?.scale)
   });
 }
 function float(name) {
@@ -65,7 +75,8 @@ function json(name) {
     }
   });
 }
-function mediumint(name, options) {
+function mediumint(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column[options?.unsigned ? "mediumint unsigned" : "mediumint"]()
@@ -77,7 +88,8 @@ function real(name) {
 function serial(name) {
   return column({ name, type: column.serial() });
 }
-function smallint(name, options) {
+function smallint(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column[options?.unsigned ? "smallint unsigned" : "smallint"]()
@@ -95,10 +107,12 @@ function mediumtext(name) {
 function longtext(name) {
   return column({ name, type: column.longtext() });
 }
-function time(name, options) {
+function time(...args) {
+  const { name, options } = columnConfig(args);
   return column({ name, type: column.time(options?.fsp) });
 }
-function timestamp(name, options) {
+function timestamp(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column.timestamp(options?.fsp),
@@ -110,16 +124,19 @@ function timestamp(name, options) {
     }
   });
 }
-function tinyint(name, options) {
+function tinyint(...args) {
+  const { name, options } = columnConfig(args);
   return column({
     name,
     type: column[options?.unsigned ? "tinyint unsigned" : "tinyint"]()
   });
 }
-function varbinary(name, options) {
+function varbinary(...args) {
+  const { name, options } = columnConfig(args);
   return column({ name, type: column.varbinary(options?.length) });
 }
-function varchar(name, options) {
+function varchar(...args) {
+  const { name, options } = columnConfig(args);
   return column({ name, type: column.varchar(options?.length) });
 }
 function year(name) {

package/dist/mysql/dialect.js

@@ -12,13 +12,16 @@ var mysqlDialect = new Dialect(
   "mysql",
   class extends Emitter {
     runtime = "mysql";
-    paramIndex = 0;
     emitValue(value) {
-      this.sql += "?";
       this.params.push(new ValueParam(value));
+      this.sql += "?";
+    }
+    emitPlaceholder(name) {
+      this.params.push(new NamedParam(name));
+      this.sql += "?";
     }
     emitJsonPath({ target, asSql, segments }) {
-      target.emitTo(this);
+      target.emit(this);
       this.sql += asSql ? "->>" : "->";
       this.sql += this.quoteString(
         `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${p}`).join("")}`
@@ -32,10 +35,6 @@ var mysqlDialect = new Dialect(
         return this.sql += this.quoteString(value);
       this.sql += this.quoteString(JSON.stringify(value));
     }
-    emitPlaceholder(name) {
-      this.sql += "?";
-      this.params.push(new NamedParam(name));
-    }
     quoteString(input) {
       return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
     }

package/dist/mysql/diff.js

@@ -1,4 +1,5 @@
 // src/mysql/diff.ts
+import { formatColumn } from "../core/Column.js";
 import { getData, getTable } from "../core/Internal.js";
 import { schema } from "../core/Schema.js";
 import { sql } from "../core/Sql.js";
@@ -106,7 +107,7 @@ var mysqlDiff = (hasTable) => {
         stmts.push(
           sql.query({
             alterTable,
-            addColumn: [column2, sql.chunk("emitColumn", schemaInstruction)]
+            addColumn: [column2, formatColumn(schemaInstruction)]
           })
         );
       } else {

package/dist/mysql.d.ts

@@ -1,7 +1,8 @@
+export { foreignKey, primaryKey, unique } from './core/Constraint.js';
 export { index, uniqueIndex } from './core/Index.js';
-export { except, exceptAll, intersect, intersectAll, union, unionAll } from './core/query/Union.js';
+export { except, exceptAll, intersect, intersectAll, union, unionAll } from './core/query/Select.js';
 export { schema as mysqlSchema } from './core/Schema.js';
-export { alias, table as mysqlTable } from './core/Table.js';
+export { alias, table as mysqlTable, tableCreator as mysqlTableCreator } from './core/Table.js';
 export * from './mysql/builder.js';
 export * from './mysql/columns.js';
 export * from './mysql/dialect.js';

package/dist/mysql.js

@@ -1,4 +1,5 @@
 // src/mysql.ts
+import { foreignKey, primaryKey, unique } from "./core/Constraint.js";
 import { index, uniqueIndex } from "./core/Index.js";
 import {
   except,
@@ -7,9 +8,13 @@ import {
   intersectAll,
   union,
   unionAll
-} from "./core/query/Union.js";
+} from "./core/query/Select.js";
 import { schema } from "./core/Schema.js";
-import { alias, table } from "./core/Table.js";
+import {
+  alias,
+  table,
+  tableCreator
+} from "./core/Table.js";
 export * from "./mysql/builder.js";
 export * from "./mysql/columns.js";
 export * from "./mysql/dialect.js";
@@ -17,12 +22,16 @@ export {
   alias,
   except,
   exceptAll,
+  foreignKey,
   index,
   intersect,
   intersectAll,
   schema as mysqlSchema,
   table as mysqlTable,
+  tableCreator as mysqlTableCreator,
+  primaryKey,
   union,
   unionAll,
+  unique,
   uniqueIndex
 };

package/dist/postgres/columns.d.ts

@@ -1,4 +1,4 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, type ColumnArguments, JsonColumn } from '../core/Column.js';
 type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 type IntervalFields = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'year to month' | 'day to hour' | 'day to minute' | 'day to second' | 'hour to minute' | 'hour to second' | 'minute to second';
 export declare function bigint(name: string | undefined, options: {
@@ -24,10 +24,10 @@ export declare function inet(name?: string): Column<string | null>;
 export declare function integer(name?: string): Column<number | null>;
 export declare const int: typeof integer;
 export declare function oid(name?: string): Column<number | null>;
-export declare function interval(name?: string, options?: {
+export declare function interval(...args: ColumnArguments<{
     fields?: IntervalFields;
     precision?: Precision;
-}): Column<string | null>;
+}>): Column<string | null>;
 export declare function serial(name?: string): Column<number>;
 export declare function boolean(name?: string): Column<boolean | null>;
 export declare function bytea(name?: string): Column<Uint8Array | null>;
@@ -36,28 +36,28 @@ export declare function json<T>(name?: string): JsonColumn<T | null>;
 export declare function jsonb<T>(name?: string): JsonColumn<T | null>;
 export declare function macaddr(name?: string): Column<string | null>;
 export declare function macaddr8(name?: string): Column<string | null>;
-export declare function numeric(name?: string, options?: {
+export declare function numeric(...args: ColumnArguments<{
     precision?: number;
     scale?: number;
-}): Column<number | null>;
+}>): Column<number | null>;
 export declare function real(name?: string): Column<number | null>;
 export declare function smallint(name?: string): Column<number | null>;
 export declare function smallserial(name?: string): Column<number | null>;
-export declare function time(name: string | undefined, options?: {
+export declare function time(...args: ColumnArguments<{
     precision?: Precision;
     withTimeZone?: boolean;
-}): Column<string | null>;
-export declare function timestamp(name: string | undefined, options?: {
+}>): Column<string | null>;
+export declare function timestamp(...args: ColumnArguments<{
     precision?: Precision;
     withTimeZone?: boolean;
-}): Column<Date | null>;
-export declare function timestamp(name?: string, options?: {
+}>): Column<Date | null>;
+export declare function timestamp(...args: ColumnArguments<{
     mode: 'string';
     precision?: Precision;
     withTimeZone?: boolean;
-}): Column<string | null>;
+}>): Column<string | null>;
 export declare function uuid(name?: string): Column<string | null>;
-export declare function varchar(name?: string, options?: {
+export declare function varchar(...args: ColumnArguments<{
     length: number;
-}): Column<string | null>;
+}>): Column<string | null>;
 export {};