@axium/server 0.28.6 → 0.30.0

package/dist/api/admin.js

@@ -1,9 +1,9 @@
 import { AuditFilter, Severity } from '@axium/core';
-import { getVersionInfo, plugins } from '@axium/core/plugins';
+import { getVersionInfo } from '@axium/core/packages';
+import { plugins } from '@axium/core/plugins';
 import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';
 import { omit } from 'utilium';
 import * as z from 'zod';
-import pkg from '../../package.json' with { type: 'json' };
 import { audit, events, getEvents } from '../audit.js';
 import { requireSession } from '../auth.js';
 import { config } from '../config.js';
@@ -30,7 +30,11 @@ addRoute({
             auditEvents,
             configFiles: config.files.size,
             plugins: plugins.size,
-            version: pkg.version,
+            versions: {
+                server: await getVersionInfo('@axium/server'),
+                core: await getVersionInfo('@axium/core'),
+                client: await getVersionInfo('@axium/client'),
+            },
         };
     },
 });
@@ -38,7 +42,9 @@ addRoute({
     path: '/api/admin/plugins',
     async GET(req) {
         await assertAdmin(this, req);
-        return await Array.fromAsync(plugins.values().map(async (p) => Object.assign(omit(p, '_hooks', '_client'), await getVersionInfo(p))));
+        return await Array.fromAsync(plugins
+            .values()
+            .map(async (p) => Object.assign(omit(p, '_hooks', '_client'), p.update_checks ? await getVersionInfo(p.specifier, p.loadedBy) : { latest: null })));
     },
 });
 addRoute({

package/dist/api/metadata.js

@@ -1,9 +1,8 @@
 import { apps } from '@axium/core';
-import { plugins } from '@axium/core/plugins';
 import { requestMethods } from '@axium/core/requests';
-import pkg from '../../package.json' with { type: 'json' };
 import { requireSession } from '../auth.js';
 import { config } from '../config.js';
+import { getAllVersions } from '../io.js';
 import { error } from '../requests.js';
 import { addRoute, routes } from '../routes.js';
 addRoute({
@@ -15,7 +14,7 @@ addRoute({
                 error(403, 'User is not an administrator');
         }
         return {
-            version: pkg.version,
+            versions: await getAllVersions(),
             routes: Object.fromEntries(routes
                 .entries()
                 .filter(([path]) => path.startsWith('/api/'))
@@ -26,7 +25,6 @@ addRoute({
                     methods: requestMethods.filter(m => m in route),
                 },
             ])),
-            plugins: Object.fromEntries(plugins.values().map(plugin => [plugin.name, plugin.version])),
         };
     },
 });

package/dist/api/register.js

@@ -1,6 +1,7 @@
 import { UserRegistration } from '@axium/core/user';
 import { generateRegistrationOptions, verifyRegistrationResponse } from '@simplewebauthn/server';
 import { randomUUID } from 'node:crypto';
+import { encodeUUID } from 'utilium';
 import * as z from 'zod';
 import { audit } from '../audit.js';
 import { createPasskey, getUser } from '../auth.js';
@@ -21,6 +22,7 @@ async function OPTIONS(request) {
     const options = await generateRegistrationOptions({
         rpName: config.auth.rp_name,
         rpID: config.auth.rp_id,
+        userID: encodeUUID(userId),
         userName: email ?? userId,
         userDisplayName: name,
         attestationType: 'none',

package/dist/api/users.js

@@ -3,7 +3,7 @@ import { preferenceDefaults, preferenceSchemas } from '@axium/core';
 import { PasskeyAuthenticationResponse, PasskeyRegistration } from '@axium/core/passkeys';
 import { LogoutSessions, UserAuthOptions, UserChangeable } from '@axium/core/user';
 import * as webauthn from '@simplewebauthn/server';
-import { omit, pick } from 'utilium';
+import { encodeUUID, omit, pick } from 'utilium';
 import * as z from 'zod';
 import { audit } from '../audit.js';
 import { checkAuthForUser, createPasskey, createVerification, getPasskey, getPasskeysByUserId, getSessions, getUser, useVerification, } from '../auth.js';
@@ -143,6 +143,7 @@ addRoute({
         const options = await webauthn.generateRegistrationOptions({
             rpName: config.auth.rp_name,
             rpID: config.auth.rp_id,
+            userID: encodeUUID(userId),
             userName: userId,
             userDisplayName: user.email,
             attestationType: 'none',

package/dist/auth.d.ts

@@ -1,9 +1,10 @@
 import type { Passkey, Session, UserInternal, Verification } from '@axium/core';
 import type { Insertable, Selectable } from 'kysely';
+import { type WithRequired } from 'utilium';
 import * as acl from './acl.js';
 import { type Schema } from './database.js';
 export declare function getUser(id: string): Promise<UserInternal>;
-export declare function updateUser({ id, ...user }: Insertable<Schema['users']>): Promise<UserInternal>;
+export declare function updateUser({ id, ...user }: WithRequired<Insertable<Schema['users']>, 'id'>): Promise<UserInternal>;
 export interface SessionInternal extends Session {
     token: string;
 }

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { type DeepRequired } from 'utilium';
 import * as z from 'zod';
-export declare const ConfigSchema: z.ZodObject<{
+export declare let ConfigSchema: z.ZodObject<{
     admin_api: z.ZodOptional<z.ZodBoolean>;
     allow_new_users: z.ZodOptional<z.ZodBoolean>;
     apps: z.ZodOptional<z.ZodObject<{
@@ -54,6 +54,7 @@ export declare const ConfigSchema: z.ZodObject<{
         build: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
+export declare function addConfig<T extends z.core.$ZodLooseShape>(shape: T): void;
 export interface Config extends z.infer<typeof ConfigSchema> {
 }
 export declare const configFiles: Map<string, File>;

package/dist/config.js

@@ -9,7 +9,7 @@ import { dirs, logger, systemDir } from './io.js';
 import { _duplicateStateWarnings, _unique } from './state.js';
 const audit_severity_levels = ['emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug'];
 const z_audit_severity = z.literal([...audit_severity_levels, ...audit_severity_levels.map(capitalize)]);
-export const ConfigSchema = z
+export let ConfigSchema = z
     .looseObject({
     /** Whether /api/admin is enabled */
     admin_api: z.boolean(),
@@ -78,6 +78,9 @@ export const ConfigSchema = z
         .partial(),
 })
     .partial();
+export function addConfig(shape) {
+    ConfigSchema = z.looseObject({ ...ConfigSchema.shape, ...shape });
+}
 export const configFiles = _unique('configFiles', new Map());
 export function plainConfig() {
     return omit(config, Object.keys(configShortcuts));

package/dist/database.d.ts

@@ -1,70 +1,21 @@
-import type { Preferences, Severity, UserInternal } from '@axium/core';
+import type { Preferences, UserInternal } from '@axium/core';
 import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 import type * as kysely from 'kysely';
 import { Kysely } from 'kysely';
+import type { Expand, Filter, MutableRecursive, ReadonlyRecursive, Tuple } from 'utilium';
 import * as z from 'zod';
 import type { VerificationRole } from './auth.js';
+import rawSchema from './db.json';
 export interface DBAccessControl {
     itemId: string;
     userId?: string | null;
     role?: string | null;
     tag?: string | null;
-    createdAt: kysely.GeneratedAlways<Date>;
+    createdAt: kysely.Generated<Date>;
 }
 export type DBBool<K extends string> = {
     [key in K]?: boolean | null;
 };
-export interface Schema {
-    users: {
-        id: string;
-        email: string;
-        name: string;
-        image?: string | null;
-        emailVerified?: Date | null;
-        preferences: Preferences;
-        isAdmin: boolean;
-        roles: string[];
-        tags: string[];
-        registeredAt: kysely.GeneratedAlways<Date>;
-        isSuspended: boolean;
-    };
-    sessions: {
-        id: kysely.GeneratedAlways<string>;
-        created: kysely.GeneratedAlways<Date>;
-        userId: string;
-        token: string;
-        expires: Date;
-        elevated: boolean;
-    };
-    verifications: {
-        userId: string;
-        token: string;
-        expires: Date;
-        role: VerificationRole;
-    };
-    passkeys: {
-        id: string;
-        name: string | null;
-        createdAt: kysely.GeneratedAlways<Date>;
-        userId: string;
-        publicKey: Uint8Array<ArrayBuffer>;
-        counter: number;
-        deviceType: CredentialDeviceType;
-        backedUp: boolean;
-        transports: AuthenticatorTransportFuture[];
-    };
-    audit_log: {
-        id: kysely.GeneratedAlways<string>;
-        userId: string | null;
-        timestamp: kysely.GeneratedAlways<Date>;
-        severity: Severity;
-        name: string;
-        tags: kysely.Generated<string[]>;
-        source: string;
-        extra: kysely.Generated<Record<string, unknown>>;
-    };
-    [key: `acl.${string}`]: DBAccessControl & Record<string, unknown>;
-}
 export type Database = Kysely<Schema> & AsyncDisposable;
 export declare let database: Database;
 export declare function connect(): Database;
@@ -106,8 +57,21 @@ export declare const _sql: (command: string, message: string) => Promise<string>
 /** Shortcut to output a warning if an error is thrown because relation already exists */
 export declare const warnExists: (error: string | Error) => void;
 export declare function init(opt: InitOptions): Promise<void>;
+declare const numberTypes: readonly ["integer", "int2", "int4", "int8", "smallint", "real", "double precision", "float4", "float8", "decimal", "numeric", "serial"];
+declare const bigintTypes: readonly ["bigint", "bigserial"];
+declare const booleanTypes: readonly ["boolean", "bool"];
+declare const stringTypes: readonly ["varchar", "char", "text"];
+declare const dateTypes: readonly ["date", "datetime", "time", "timetz", "timestamp", "timestamptz"];
+declare const binaryTypes: readonly ["binary", "bytea", "varbinary", "blob"];
+declare const numericRangeTypes: readonly ["int4range", "numrange"];
+declare const stringRangeTypes: readonly ["tsrange", "tstzrange", "daterange"];
+declare const multirangeTypes: readonly ["int4multirange", "int8multirange", "nummultirange", "tsmultirange", "tstzmultirange", "datemultirange"];
+declare const _primitive: z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">;
+declare const _ColumnType: z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>;
+declare const ColumnType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
+export type ColumnType = z.infer<typeof ColumnType>;
 export declare const Column: z.ZodObject<{
-    type: z.ZodString;
+    type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
     required: z.ZodDefault<z.ZodBoolean>;
     unique: z.ZodDefault<z.ZodBoolean>;
     primary: z.ZodDefault<z.ZodBoolean>;
@@ -143,7 +107,7 @@ export declare const Constraint: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type Constraint = z.infer<typeof Constraint>;
 export declare const Table: z.ZodObject<{
     columns: z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodString;
+        type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
         required: z.ZodDefault<z.ZodBoolean>;
         unique: z.ZodDefault<z.ZodBoolean>;
         primary: z.ZodDefault<z.ZodBoolean>;
@@ -186,7 +150,7 @@ export declare function parseIndex(value: IndexString): {
 export declare const SchemaDecl: z.ZodObject<{
     tables: z.ZodRecord<z.ZodString, z.ZodObject<{
         columns: z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
             required: z.ZodDefault<z.ZodBoolean>;
             unique: z.ZodDefault<z.ZodBoolean>;
             primary: z.ZodDefault<z.ZodBoolean>;
@@ -223,7 +187,7 @@ export declare const SchemaDecl: z.ZodObject<{
 export interface SchemaDecl extends z.infer<typeof SchemaDecl> {
 }
 export declare const ColumnDelta: z.ZodObject<{
-    type: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>>;
     default: z.ZodOptional<z.ZodString>;
     ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
 }, z.core.$strict>;
@@ -231,7 +195,7 @@ export interface ColumnDelta extends z.infer<typeof ColumnDelta> {
 }
 export declare const TableDelta: z.ZodObject<{
     add_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodString;
+        type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
         required: z.ZodDefault<z.ZodBoolean>;
         unique: z.ZodDefault<z.ZodBoolean>;
         primary: z.ZodDefault<z.ZodBoolean>;
@@ -248,7 +212,7 @@ export declare const TableDelta: z.ZodObject<{
     }, z.core.$strict>>>>;
     drop_columns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     alter_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>>;
         default: z.ZodOptional<z.ZodString>;
         ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
     }, z.core.$strict>>>>;
@@ -276,7 +240,7 @@ export declare const VersionDelta: z.ZodObject<{
     delta: z.ZodLiteral<true>;
     add_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         columns: z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
             required: z.ZodDefault<z.ZodBoolean>;
             unique: z.ZodDefault<z.ZodBoolean>;
             primary: z.ZodDefault<z.ZodBoolean>;
@@ -311,7 +275,7 @@ export declare const VersionDelta: z.ZodObject<{
     drop_tables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     alter_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         add_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
             required: z.ZodDefault<z.ZodBoolean>;
             unique: z.ZodDefault<z.ZodBoolean>;
             primary: z.ZodDefault<z.ZodBoolean>;
@@ -328,7 +292,7 @@ export declare const VersionDelta: z.ZodObject<{
         }, z.core.$strict>>>>;
         drop_columns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         alter_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>>;
             default: z.ZodOptional<z.ZodString>;
             ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
         }, z.core.$strict>>>>;
@@ -360,7 +324,7 @@ export declare const SchemaFile: z.ZodObject<{
     versions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         tables: z.ZodRecord<z.ZodString, z.ZodObject<{
             columns: z.ZodRecord<z.ZodString, z.ZodObject<{
-                type: z.ZodString;
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
                 required: z.ZodDefault<z.ZodBoolean>;
                 unique: z.ZodDefault<z.ZodBoolean>;
                 primary: z.ZodDefault<z.ZodBoolean>;
@@ -398,7 +362,7 @@ export declare const SchemaFile: z.ZodObject<{
         delta: z.ZodLiteral<true>;
         add_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             columns: z.ZodRecord<z.ZodString, z.ZodObject<{
-                type: z.ZodString;
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
                 required: z.ZodDefault<z.ZodBoolean>;
                 unique: z.ZodDefault<z.ZodBoolean>;
                 primary: z.ZodDefault<z.ZodBoolean>;
@@ -433,7 +397,7 @@ export declare const SchemaFile: z.ZodObject<{
         drop_tables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         alter_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             add_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                type: z.ZodString;
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
                 required: z.ZodDefault<z.ZodBoolean>;
                 unique: z.ZodDefault<z.ZodBoolean>;
                 primary: z.ZodDefault<z.ZodBoolean>;
@@ -450,7 +414,7 @@ export declare const SchemaFile: z.ZodObject<{
             }, z.core.$strict>>>>;
             drop_columns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             alter_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                type: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>>;
                 default: z.ZodOptional<z.ZodString>;
                 ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
             }, z.core.$strict>>>>;
@@ -482,6 +446,107 @@ export declare const SchemaFile: z.ZodObject<{
 export interface SchemaFile extends z.infer<typeof SchemaFile> {
 }
 export declare function getSchemaFiles(): Generator<[string, SchemaFile]>;
+export type ApplyColumnDelta<C extends z.input<typeof Column>, D extends z.input<typeof ColumnDelta>> = Omit<C, 'type' | 'default' | 'required'> & {
+    type: D extends {
+        type: infer T;
+    } ? T : C['type'];
+    default: D extends {
+        ops: readonly any[];
+    } ? 'drop_default' extends D['ops'][number] ? undefined : D extends {
+        default: infer Def;
+    } ? Def : C['default'] : D extends {
+        default: infer Def;
+    } ? Def : C['default'];
+    required: D extends {
+        ops: readonly any[];
+    } ? 'set_required' extends D['ops'][number] ? true : 'drop_required' extends D['ops'][number] ? false : C['required'] : C['required'];
+};
+export type ApplyTableDelta<T extends z.input<typeof Table>, D extends z.input<typeof TableDelta>> = {
+    columns: {
+        [K in keyof T['columns'] as K extends (D extends {
+            drop_columns: any[];
+        } ? D['drop_columns'][number] : never) ? never : K]: K extends keyof (D extends {
+            alter_columns: any;
+        } ? D['alter_columns'] : {}) ? ApplyColumnDelta<T['columns'][K], (D['alter_columns'] & {})[K & keyof D['alter_columns']]> : T['columns'][K];
+    } & (D extends {
+        add_columns: infer A;
+    } ? A : {});
+    constraints: {
+        [K in keyof T['constraints'] as K extends (D extends {
+            drop_constraints: any[];
+        } ? D['drop_constraints'][number] : never) ? never : K]: T['constraints'][K];
+    } & (D extends {
+        add_constraints: infer A;
+    } ? A : {});
+};
+export type ApplyDeltaToSchema<S extends z.input<typeof SchemaDecl>, D extends z.input<typeof VersionDelta>> = {
+    tables: {
+        [K in keyof S['tables'] as K extends (D extends {
+            drop_tables: any[];
+        } ? D['drop_tables'][number] : never) ? never : K]: K extends keyof (D extends {
+            alter_tables: any;
+        } ? D['alter_tables'] : {}) ? ApplyTableDelta<S['tables'][K], (D['alter_tables'] & {})[K & keyof D['alter_tables']]> : S['tables'][K];
+    } & (D extends {
+        add_tables: infer A;
+    } ? A : {});
+    indexes: D extends {
+        add_indexes: infer Add;
+        drop_indexes: infer Drop;
+    } ? [...Filter<Drop extends readonly any[] ? Drop[number] : never, S['indexes'] & {}>, ...(Add extends readonly any[] ? Add : [])] : S['indexes'];
+};
+type ResolveVersions<V extends readonly any[], Current extends z.input<typeof SchemaDecl> = {
+    tables: {};
+    indexes: [];
+}> = V extends readonly [
+    infer Head extends z.input<typeof VersionDelta> | (z.input<typeof SchemaDecl> & {
+        delta: false;
+    }),
+    ...infer Tail extends (z.input<typeof VersionDelta> | (z.input<typeof SchemaDecl> & {
+        delta: false;
+    }))[]
+] ? Head extends z.input<typeof VersionDelta> ? ResolveVersions<Tail, ApplyDeltaToSchema<Current, Head>> : Head extends z.input<typeof SchemaDecl> ? ResolveVersions<Tail, Head> : never : Current;
+export type FullSchema<S extends z.input<typeof SchemaFile>> = ResolveVersions<S['versions']>;
+type __RangeContent = string | number | bigint | boolean | null | undefined;
+type _Range<T extends __RangeContent> = `${'(' | '['}${T},${T}${')' | ']'}`;
+type _MultiRange = `{${string}}`;
+interface ColumnValueMap extends Record<(typeof numberTypes)[number], number>, Record<(typeof bigintTypes)[number], bigint>, Record<(typeof booleanTypes)[number], boolean>, Record<(typeof stringTypes)[number], string>, Record<(typeof dateTypes)[number], Date>, Record<(typeof binaryTypes)[number], Uint8Array<ArrayBuffer>>, Record<(typeof numericRangeTypes)[number], _Range<number>>, Record<(typeof stringRangeTypes)[number], _Range<string>>, Record<(typeof multirangeTypes)[number], _MultiRange> {
+    int8range: _Range<bigint>;
+    uuid: string;
+    json: any;
+    jsonb: any;
+}
+type ColumnTypeToValue<T extends ColumnType> = T extends `${infer CT extends z.infer<typeof _ColumnType>}[${infer N extends '' | number}]` ? N extends number ? Tuple<ColumnTypeToValue<CT>, N> : ColumnTypeToValue<CT>[] : T extends `${infer Base extends z.infer<typeof _primitive>}(${string})` ? ColumnTypeToValue<Base> : T extends keyof ColumnValueMap ? ColumnValueMap[T] : never;
+/**
+ * Convert a column definition into the Kysely database schema type
+ */
+export type ColumnSchema<T extends z.input<typeof Column>> = T['default'] extends {} ? kysely.Generated<ColumnTypeToValue<T['type']>> : T['required'] extends true ? ColumnTypeToValue<T['type']> : ColumnTypeToValue<T['type']> | null;
+/**
+ * Convert a table definition into the Kysely database schema type
+ */
+export type TableSchema<T extends z.input<typeof Table>> = {
+    [K in keyof T['columns']]: ColumnSchema<T['columns'][K]>;
+};
+type _DBFromSchema<TBs extends Record<string, z.input<typeof Table>>> = {
+    [K in keyof TBs]: Expand<TableSchema<TBs[K]>>;
+};
+/**
+ * Convert an entire schema definition file info the Kysely database schema type
+ */
+export type DatabaseFromSchemaFile<S extends ReadonlyRecursive<z.input<typeof SchemaFile>>> = _DBFromSchema<FullSchema<MutableRecursive<S>>['tables']>;
+type RawDB = DatabaseFromSchemaFile<typeof rawSchema>;
+export interface Schema extends Omit<RawDB, 'users' | 'verifications' | 'passkeys'> {
+    users: Expand<RawDB['users'] & {
+        preferences: kysely.Generated<Preferences>;
+    }>;
+    verifications: Expand<RawDB['verifications'] & {
+        role: VerificationRole;
+    }>;
+    passkeys: Expand<Omit<RawDB['passkeys'], 'transports'> & {
+        deviceType: CredentialDeviceType;
+        transports: AuthenticatorTransportFuture[];
+    }>;
+    [key: `acl.${string}`]: DBAccessControl & Record<string, unknown>;
+}
 /**
  * Get the active schema
  */
@@ -529,3 +594,4 @@ export interface CheckOptions extends OpOptions {
 export declare function checkTableTypes<TB extends keyof Schema & string>(tableName: TB, types: Table, opt: CheckOptions): Promise<void>;
 export declare function clean(opt: Partial<OpOptions>): Promise<void>;
 export declare function rotatePassword(): Promise<void>;
+export {};

package/dist/database.js

@@ -63,6 +63,7 @@ import * as z from 'zod';
 import config from './config.js';
 import rawSchema from './db.json' with { type: 'json' };
 import { dirs, systemDir } from './io.js';
+pg.types.setTypeParser(pg.types.builtins.INT8, BigInt);
 const sym = Symbol.for('Axium:database');
 export let database;
 export function connect() {
@@ -230,8 +231,55 @@ export async function init(opt) {
             await result_1;
     }
 }
+const numberTypes = [
+    'integer',
+    'int2',
+    'int4',
+    'int8',
+    'smallint',
+    'real',
+    'double precision',
+    'float4',
+    'float8',
+    'decimal',
+    'numeric',
+    'serial',
+];
+const bigintTypes = ['bigint', 'bigserial'];
+const booleanTypes = ['boolean', 'bool'];
+const stringTypes = ['varchar', 'char', 'text'];
+const dateTypes = ['date', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz'];
+const binaryTypes = ['binary', 'bytea', 'varbinary', 'blob'];
+const numericRangeTypes = ['int4range', 'numrange'];
+const stringRangeTypes = ['tsrange', 'tstzrange', 'daterange'];
+const multirangeTypes = ['int4multirange', 'int8multirange', 'nummultirange', 'tsmultirange', 'tstzmultirange', 'datemultirange'];
+const _primitive = z.literal([
+    ...numberTypes,
+    ...bigintTypes,
+    ...booleanTypes,
+    ...stringTypes,
+    ...dateTypes,
+    ...binaryTypes,
+    ...numericRangeTypes,
+    ...stringRangeTypes,
+    ...multirangeTypes,
+    'uuid',
+    'json',
+    'jsonb',
+]);
+const _ColumnType = z.union([
+    _primitive,
+    z.templateLiteral([
+        z.literal(['char', 'varchar', 'binary', 'varbinary', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz']),
+        '(',
+        z.int().nonnegative(),
+        ')',
+    ]),
+    z.templateLiteral([z.literal(['decimal', 'numeric']), '(', z.int().nonnegative(), z.literal([',', ', ']), z.int().nonnegative(), ')']),
+]);
+const ColumnType = z.union([_ColumnType, z.templateLiteral([_ColumnType, '[', z.int().nonnegative().optional(), ']'])]);
 export const Column = z.strictObject({
-    type: z.string(),
+    type: ColumnType,
     required: z.boolean().default(false),
     unique: z.boolean().default(false),
     primary: z.boolean().default(false),
@@ -275,7 +323,7 @@ export const SchemaDecl = z.strictObject({
     indexes: IndexString.array().optional().default([]),
 });
 export const ColumnDelta = z.strictObject({
-    type: z.string().optional(),
+    type: ColumnType.optional(),
     default: z.string().optional(),
     ops: z.literal(['drop_default', 'set_required', 'drop_required']).array().optional(),
 });

package/dist/db.json

@@ -65,6 +65,16 @@
                 }
             },
             "indexes": ["sessions:id", "passkeys:userId"]
+        },
+        {
+            "delta": true,
+            "alter_tables": {
+                "users": {
+                    "alter_columns": {
+                        "name": { "ops": ["set_required"] }
+                    }
+                }
+            }
         }
     ],
     "wipe": ["users", "verifications", "passkeys", "sessions", "audit_log"]

package/dist/io.d.ts

@@ -1,3 +1,4 @@
+import { type PackageVersionInfo } from '@axium/core/packages';
 import { Logger } from 'logzen';
 export declare const systemDir = "/etc/axium";
 export declare const dirs: string[];
@@ -23,3 +24,4 @@ export interface PortOptions {
  * If the origin has a port, passkeys do not work correctly with some password managers.
  */
 export declare function restrictedPorts(opt: PortOptions): Promise<void>;
+export declare function getAllVersions(): Promise<PackageVersionInfo[]>;

package/dist/io.js

@@ -1,4 +1,6 @@
 import * as io from '@axium/core/node/io';
+import { getVersionInfo } from '@axium/core/packages';
+import { plugins } from '@axium/core/plugins';
 import { Logger } from 'logzen';
 import * as fs from 'node:fs';
 import { dirname, join, resolve } from 'node:path/posix';
@@ -77,3 +79,11 @@ export async function restrictedPorts(opt) {
         }
     }
 }
+export async function getAllVersions() {
+    return await Array.fromAsync([
+        ...plugins.values().map(p => getVersionInfo(p.specifier, p.loadedBy)),
+        getVersionInfo('@axium/server'),
+        getVersionInfo('@axium/core'),
+        getVersionInfo('@axium/client'),
+    ]);
+}

package/dist/main.js

@@ -442,7 +442,7 @@ try {
             lengths.available = Math.max(lengths.available || 0, available.length);
         }
         for (const [i, entry] of entries.entries()) {
-            console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(i === 0 ? ['whiteBright', 'underline'] : entry[key] === undefined ? 'none' : [], entry[key].padStart(lengths[key]))));
+            console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(i === 0 ? ['whiteBright', 'underline'] : entry[key] === undefined ? 'reset' : [], entry[key].padStart(lengths[key]))));
         }
     });
     axiumConfig = program

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/server",
-	"version": "0.28.6",
+	"version": "0.30.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -48,9 +48,9 @@
 	},
 	"peerDependencies": {
 		"@axium/client": ">=0.9.5",
-		"@axium/core": ">=0.12.0",
+		"@axium/core": ">=0.14.0",
 		"kysely": "^0.28.0",
-		"utilium": "^2.3.8",
+		"utilium": "^2.6.0",
 		"zod": "^4.0.5"
 	},
 	"dependencies": {

package/routes/admin/+page.svelte

@@ -1,6 +1,7 @@
 <script>
 	import { Version } from '@axium/client/components';
 	import { Severity } from '@axium/core';
+	import { capitalize } from 'utilium';
 
 	const { data } = $props();
 </script>
@@ -11,7 +12,10 @@
 
 <h2>Administration</h2>
 
-<p>Axium Server <Version v={data.version} latest={data.latest} /></p>
+{#each ['server', 'core', 'client'] as name}
+	{@const info = data.versions[name]}
+	<p>Axium {capitalize(name)} <Version v={info.version} latest={info.latest} /></p>
+{/each}
 
 <h3><a href="/admin/users">Users</a></h3>
 

package/schemas/db.json

@@ -9,7 +9,7 @@
         "versions": {
             "type": "array",
             "items": {
-                "anyOf": [
+                "oneOf": [
                     {
                         "type": "object",
                         "properties": {
@@ -30,7 +30,72 @@
                                                 "type": "object",
                                                 "properties": {
                                                     "type": {
-                                                        "type": "string"
+                                                        "anyOf": [
+                                                            {
+                                                                "anyOf": [
+                                                                    {
+                                                                        "type": "string",
+                                                                        "enum": [
+                                                                            "integer",
+                                                                            "int2",
+                                                                            "int4",
+                                                                            "int8",
+                                                                            "smallint",
+                                                                            "real",
+                                                                            "double precision",
+                                                                            "float4",
+                                                                            "float8",
+                                                                            "decimal",
+                                                                            "numeric",
+                                                                            "serial",
+                                                                            "bigint",
+                                                                            "bigserial",
+                                                                            "boolean",
+                                                                            "bool",
+                                                                            "varchar",
+                                                                            "char",
+                                                                            "text",
+                                                                            "date",
+                                                                            "datetime",
+                                                                            "time",
+                                                                            "timetz",
+                                                                            "timestamp",
+                                                                            "timestamptz",
+                                                                            "binary",
+                                                                            "bytea",
+                                                                            "varbinary",
+                                                                            "blob",
+                                                                            "int4range",
+                                                                            "numrange",
+                                                                            "tsrange",
+                                                                            "tstzrange",
+                                                                            "daterange",
+                                                                            "int4multirange",
+                                                                            "int8multirange",
+                                                                            "nummultirange",
+                                                                            "tsmultirange",
+                                                                            "tstzmultirange",
+                                                                            "datemultirange",
+                                                                            "uuid",
+                                                                            "json",
+                                                                            "jsonb"
+                                                                        ]
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)$"
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\)$"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "type": "string",
+                                                                "pattern": "^((integer|int2|int4|int8|smallint|real|double precision|float4|float8|decimal|numeric|serial|bigint|bigserial|boolean|bool|varchar|char|text|date|datetime|time|timetz|timestamp|timestamptz|binary|bytea|varbinary|blob|int4range|numrange|tsrange|tstzrange|daterange|int4multirange|int8multirange|nummultirange|tsmultirange|tstzmultirange|datemultirange|uuid|json|jsonb)|(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)|(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\))\\[(-?\\d+)?\\]$"
+                                                            }
+                                                        ]
                                                     },
                                                     "required": {
                                                         "default": false,
@@ -75,7 +140,7 @@
                                                 "type": "string"
                                             },
                                             "additionalProperties": {
-                                                "anyOf": [
+                                                "oneOf": [
                                                     {
                                                         "type": "object",
                                                         "properties": {
@@ -221,7 +286,72 @@
                                                 "type": "object",
                                                 "properties": {
                                                     "type": {
-                                                        "type": "string"
+                                                        "anyOf": [
+                                                            {
+                                                                "anyOf": [
+                                                                    {
+                                                                        "type": "string",
+                                                                        "enum": [
+                                                                            "integer",
+                                                                            "int2",
+                                                                            "int4",
+                                                                            "int8",
+                                                                            "smallint",
+                                                                            "real",
+                                                                            "double precision",
+                                                                            "float4",
+                                                                            "float8",
+                                                                            "decimal",
+                                                                            "numeric",
+                                                                            "serial",
+                                                                            "bigint",
+                                                                            "bigserial",
+                                                                            "boolean",
+                                                                            "bool",
+                                                                            "varchar",
+                                                                            "char",
+                                                                            "text",
+                                                                            "date",
+                                                                            "datetime",
+                                                                            "time",
+                                                                            "timetz",
+                                                                            "timestamp",
+                                                                            "timestamptz",
+                                                                            "binary",
+                                                                            "bytea",
+                                                                            "varbinary",
+                                                                            "blob",
+                                                                            "int4range",
+                                                                            "numrange",
+                                                                            "tsrange",
+                                                                            "tstzrange",
+                                                                            "daterange",
+                                                                            "int4multirange",
+                                                                            "int8multirange",
+                                                                            "nummultirange",
+                                                                            "tsmultirange",
+                                                                            "tstzmultirange",
+                                                                            "datemultirange",
+                                                                            "uuid",
+                                                                            "json",
+                                                                            "jsonb"
+                                                                        ]
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)$"
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\)$"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "type": "string",
+                                                                "pattern": "^((integer|int2|int4|int8|smallint|real|double precision|float4|float8|decimal|numeric|serial|bigint|bigserial|boolean|bool|varchar|char|text|date|datetime|time|timetz|timestamp|timestamptz|binary|bytea|varbinary|blob|int4range|numrange|tsrange|tstzrange|daterange|int4multirange|int8multirange|nummultirange|tsmultirange|tstzmultirange|datemultirange|uuid|json|jsonb)|(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)|(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\))\\[(-?\\d+)?\\]$"
+                                                            }
+                                                        ]
                                                     },
                                                     "required": {
                                                         "default": false,
@@ -266,7 +396,7 @@
                                                 "type": "string"
                                             },
                                             "additionalProperties": {
-                                                "anyOf": [
+                                                "oneOf": [
                                                     {
                                                         "type": "object",
                                                         "properties": {
@@ -394,7 +524,72 @@
                                                 "type": "object",
                                                 "properties": {
                                                     "type": {
-                                                        "type": "string"
+                                                        "anyOf": [
+                                                            {
+                                                                "anyOf": [
+                                                                    {
+                                                                        "type": "string",
+                                                                        "enum": [
+                                                                            "integer",
+                                                                            "int2",
+                                                                            "int4",
+                                                                            "int8",
+                                                                            "smallint",
+                                                                            "real",
+                                                                            "double precision",
+                                                                            "float4",
+                                                                            "float8",
+                                                                            "decimal",
+                                                                            "numeric",
+                                                                            "serial",
+                                                                            "bigint",
+                                                                            "bigserial",
+                                                                            "boolean",
+                                                                            "bool",
+                                                                            "varchar",
+                                                                            "char",
+                                                                            "text",
+                                                                            "date",
+                                                                            "datetime",
+                                                                            "time",
+                                                                            "timetz",
+                                                                            "timestamp",
+                                                                            "timestamptz",
+                                                                            "binary",
+                                                                            "bytea",
+                                                                            "varbinary",
+                                                                            "blob",
+                                                                            "int4range",
+                                                                            "numrange",
+                                                                            "tsrange",
+                                                                            "tstzrange",
+                                                                            "daterange",
+                                                                            "int4multirange",
+                                                                            "int8multirange",
+                                                                            "nummultirange",
+                                                                            "tsmultirange",
+                                                                            "tstzmultirange",
+                                                                            "datemultirange",
+                                                                            "uuid",
+                                                                            "json",
+                                                                            "jsonb"
+                                                                        ]
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)$"
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\)$"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "type": "string",
+                                                                "pattern": "^((integer|int2|int4|int8|smallint|real|double precision|float4|float8|decimal|numeric|serial|bigint|bigserial|boolean|bool|varchar|char|text|date|datetime|time|timetz|timestamp|timestamptz|binary|bytea|varbinary|blob|int4range|numrange|tsrange|tstzrange|daterange|int4multirange|int8multirange|nummultirange|tsmultirange|tstzmultirange|datemultirange|uuid|json|jsonb)|(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)|(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\))\\[(-?\\d+)?\\]$"
+                                                            }
+                                                        ]
                                                     },
                                                     "required": {
                                                         "default": false,
@@ -449,7 +644,72 @@
                                                 "type": "object",
                                                 "properties": {
                                                     "type": {
-                                                        "type": "string"
+                                                        "anyOf": [
+                                                            {
+                                                                "anyOf": [
+                                                                    {
+                                                                        "type": "string",
+                                                                        "enum": [
+                                                                            "integer",
+                                                                            "int2",
+                                                                            "int4",
+                                                                            "int8",
+                                                                            "smallint",
+                                                                            "real",
+                                                                            "double precision",
+                                                                            "float4",
+                                                                            "float8",
+                                                                            "decimal",
+                                                                            "numeric",
+                                                                            "serial",
+                                                                            "bigint",
+                                                                            "bigserial",
+                                                                            "boolean",
+                                                                            "bool",
+                                                                            "varchar",
+                                                                            "char",
+                                                                            "text",
+                                                                            "date",
+                                                                            "datetime",
+                                                                            "time",
+                                                                            "timetz",
+                                                                            "timestamp",
+                                                                            "timestamptz",
+                                                                            "binary",
+                                                                            "bytea",
+                                                                            "varbinary",
+                                                                            "blob",
+                                                                            "int4range",
+                                                                            "numrange",
+                                                                            "tsrange",
+                                                                            "tstzrange",
+                                                                            "daterange",
+                                                                            "int4multirange",
+                                                                            "int8multirange",
+                                                                            "nummultirange",
+                                                                            "tsmultirange",
+                                                                            "tstzmultirange",
+                                                                            "datemultirange",
+                                                                            "uuid",
+                                                                            "json",
+                                                                            "jsonb"
+                                                                        ]
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)$"
+                                                                    },
+                                                                    {
+                                                                        "type": "string",
+                                                                        "pattern": "^(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\)$"
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "type": "string",
+                                                                "pattern": "^((integer|int2|int4|int8|smallint|real|double precision|float4|float8|decimal|numeric|serial|bigint|bigserial|boolean|bool|varchar|char|text|date|datetime|time|timetz|timestamp|timestamptz|binary|bytea|varbinary|blob|int4range|numrange|tsrange|tstzrange|daterange|int4multirange|int8multirange|nummultirange|tsmultirange|tstzmultirange|datemultirange|uuid|json|jsonb)|(char|varchar|binary|varbinary|datetime|time|timetz|timestamp|timestamptz)\\(-?\\d+\\)|(decimal|numeric)\\(-?\\d+(,|, )-?\\d+\\))\\[(-?\\d+)?\\]$"
+                                                            }
+                                                        ]
                                                     },
                                                     "default": {
                                                         "type": "string"
@@ -476,7 +736,7 @@
                                                 "type": "string"
                                             },
                                             "additionalProperties": {
-                                                "anyOf": [
+                                                "oneOf": [
                                                     {
                                                         "type": "object",
                                                         "properties": {