@axium/server 0.26.3 → 0.28.0

package/dist/config.js

@@ -30,7 +30,6 @@ export const ConfigSchema = z
         .partial(),
     auth: z
         .looseObject({
-        origin: z.string(),
         /** In minutes */
         passkey_probation: z.number(),
         rp_id: z.string(),
@@ -62,6 +61,7 @@ export const ConfigSchema = z
         console: z.boolean(),
     })
         .partial(),
+    origin: z.string(),
     request_size_limit: z.number().min(0).optional(),
     show_duplicate_state: z.boolean(),
     web: z
@@ -95,7 +95,6 @@ export const defaultConfig = {
         auto_suspend: 'critical',
     },
     auth: {
-        origin: 'https://test.localhost',
         passkey_probation: 60,
         rp_id: 'test.localhost',
         rp_name: 'Axium',
@@ -122,6 +121,7 @@ export const defaultConfig = {
         console: true,
         level: 'info',
     },
+    origin: 'https://test.localhost',
     show_duplicate_state: false,
     request_size_limit: 0,
     web: {
@@ -228,8 +228,11 @@ export async function loadConfig(path, options = {}) {
     io.debug('Loaded config: ' + path);
     for (const include of file.include ?? [])
         await loadConfig(resolve(dirname(path), include), { ...options, optional: true, _markIncluded: true });
-    for (const plugin of file.plugins ?? [])
-        await loadPlugin('server', plugin, path, options.safe);
+    for (const pluginPath of file.plugins ?? []) {
+        const plugin = await loadPlugin('server', pluginPath, path, options.safe);
+        if (!plugin)
+            continue;
+    }
 }
 export async function loadDefaultConfigs(safe = false) {
     for (const path of findConfigPaths()) {
@@ -277,9 +280,7 @@ export function saveConfigTo(path, changed) {
  */
 export function findConfigPaths() {
     const paths = dirs.map(dir => join(dir, 'config.json'));
-    if (process.env.AXIUM_CONFIG)
+    if (process.env.AXIUM_CONFIG && !paths.includes(process.env.AXIUM_CONFIG))
         paths.push(process.env.AXIUM_CONFIG);
     return paths;
 }
-if (process.env.AXIUM_CONFIG)
-    await loadConfig(process.env.AXIUM_CONFIG);

package/dist/database.d.ts

@@ -1,14 +1,19 @@
-import type { Permission, Preferences, Severity, UserInternal } from '@axium/core';
+import type { Preferences, Severity, UserInternal } from '@axium/core';
 import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 import type * as kysely from 'kysely';
 import { Kysely } from 'kysely';
+import * as z from 'zod';
 import type { VerificationRole } from './auth.js';
 export interface DBAccessControl {
     itemId: string;
-    userId: string;
+    userId?: string | null;
+    role?: string | null;
+    tag?: string | null;
     createdAt: kysely.GeneratedAlways<Date>;
-    permission: Permission;
 }
+export type DBBool<K extends string> = {
+    [key in K]?: boolean | null;
+};
 export interface Schema {
     users: {
         id: string;
@@ -58,7 +63,7 @@ export interface Schema {
         source: string;
         extra: kysely.Generated<Record<string, unknown>>;
     };
-    [key: `acl.${string}`]: DBAccessControl;
+    [key: `acl.${string}`]: DBAccessControl & Record<string, unknown>;
 }
 export type Database = Kysely<Schema> & AsyncDisposable;
 export declare let database: Database;
@@ -75,6 +80,10 @@ export type TablesMatching<T> = (string & keyof Schema) & keyof {
 export declare function userFromId<TB extends TablesMatching<{
     userId: string;
 }>>(builder: kysely.ExpressionBuilder<Schema, TB>): kysely.AliasedRawBuilder<UserInternal, 'user' | TB>;
+/**
+ * Used for `update ... set ... from`
+ */
+export declare function values<R extends Record<string, unknown>, A extends string>(records: R[], alias: A): kysely.AliasedRawBuilder<R, A>;
 export interface Stats {
     users: number;
     passkeys: number;
@@ -90,26 +99,415 @@ export interface InitOptions extends OpOptions {
 }
 export declare function shouldRecreate(opt: InitOptions): boolean;
 export declare function getHBA(opt: OpOptions): Promise<[content: string, writeBack: (newContent: string) => void]>;
+/** @internal @hidden */
+export declare const _pgHba = "\nlocal axium axium md5\nhost  axium axium 127.0.0.1/32 md5\nhost  axium axium ::1/128 md5\n";
+/** @internal @hidden */
+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 createIndex(table: string, column: string, mod?: (ib: kysely.CreateIndexBuilder<string>) => kysely.CreateIndexBuilder<string>): Promise<void>;
 export declare function init(opt: InitOptions): Promise<void>;
+export declare const Column: z.ZodObject<{
+    type: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    unique: z.ZodDefault<z.ZodBoolean>;
+    primary: z.ZodDefault<z.ZodBoolean>;
+    references: z.ZodOptional<z.ZodString>;
+    onDelete: z.ZodOptional<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "no action": "no action";
+        "set null": "set null";
+        "set default": "set default";
+    }>>;
+    default: z.ZodOptional<z.ZodAny>;
+    check: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface Column extends z.infer<typeof Column> {
+}
+export declare const Constraint: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"primary_key">;
+    on: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"foreign_key">;
+    on: z.ZodArray<z.ZodString>;
+    target: z.ZodString;
+    references: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"unique">;
+    on: z.ZodArray<z.ZodString>;
+    nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"check">;
+    check: z.ZodString;
+}, z.core.$strict>], "type">;
+export type Constraint = z.infer<typeof Constraint>;
+export declare const Table: z.ZodObject<{
+    columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+        primary: z.ZodDefault<z.ZodBoolean>;
+        references: z.ZodOptional<z.ZodString>;
+        onDelete: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
+        default: z.ZodOptional<z.ZodAny>;
+        check: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"primary_key">;
+        on: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"foreign_key">;
+        on: z.ZodArray<z.ZodString>;
+        target: z.ZodString;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"unique">;
+        on: z.ZodArray<z.ZodString>;
+        nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"check">;
+        check: z.ZodString;
+    }, z.core.$strict>], "type">>>>;
+}, z.core.$strict>;
+export interface Table extends z.infer<typeof Table> {
+}
+export declare const IndexString: z.ZodTemplateLiteral<`${string}:${string}`>;
+export type IndexString = z.infer<typeof IndexString>;
+export declare function parseIndex(value: IndexString): {
+    table: string;
+    column: string;
+};
+export declare const SchemaDecl: z.ZodObject<{
+    tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+        columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            primary: z.ZodDefault<z.ZodBoolean>;
+            references: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            default: z.ZodOptional<z.ZodAny>;
+            check: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"primary_key">;
+            on: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"foreign_key">;
+            on: z.ZodArray<z.ZodString>;
+            target: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"unique">;
+            on: z.ZodArray<z.ZodString>;
+            nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"check">;
+            check: z.ZodString;
+        }, z.core.$strict>], "type">>>>;
+    }, z.core.$strict>>;
+    indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+}, z.core.$strict>;
+export interface SchemaDecl extends z.infer<typeof SchemaDecl> {
+}
+export declare const ColumnDelta: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+    ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
+}, z.core.$strict>;
+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;
+        required: z.ZodDefault<z.ZodBoolean>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+        primary: z.ZodDefault<z.ZodBoolean>;
+        references: z.ZodOptional<z.ZodString>;
+        onDelete: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
+        default: z.ZodOptional<z.ZodAny>;
+        check: z.ZodOptional<z.ZodString>;
+    }, 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>;
+        default: z.ZodOptional<z.ZodString>;
+        ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
+    }, z.core.$strict>>>>;
+    add_constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"primary_key">;
+        on: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"foreign_key">;
+        on: z.ZodArray<z.ZodString>;
+        target: z.ZodString;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"unique">;
+        on: z.ZodArray<z.ZodString>;
+        nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"check">;
+        check: z.ZodString;
+    }, z.core.$strict>], "type">>>>;
+    drop_constraints: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+export interface TableDelta extends z.infer<typeof TableDelta> {
+}
+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;
+            required: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            primary: z.ZodDefault<z.ZodBoolean>;
+            references: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            default: z.ZodOptional<z.ZodAny>;
+            check: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"primary_key">;
+            on: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"foreign_key">;
+            on: z.ZodArray<z.ZodString>;
+            target: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"unique">;
+            on: z.ZodArray<z.ZodString>;
+            nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"check">;
+            check: z.ZodString;
+        }, z.core.$strict>], "type">>>>;
+    }, z.core.$strict>>>>;
+    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;
+            required: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            primary: z.ZodDefault<z.ZodBoolean>;
+            references: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            default: z.ZodOptional<z.ZodAny>;
+            check: z.ZodOptional<z.ZodString>;
+        }, 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>;
+            default: z.ZodOptional<z.ZodString>;
+            ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
+        }, z.core.$strict>>>>;
+        add_constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"primary_key">;
+            on: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"foreign_key">;
+            on: z.ZodArray<z.ZodString>;
+            target: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"unique">;
+            on: z.ZodArray<z.ZodString>;
+            nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"check">;
+            check: z.ZodString;
+        }, z.core.$strict>], "type">>>>;
+        drop_constraints: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>>>;
+    add_indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+    drop_indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+}, z.core.$strict>;
+export interface VersionDelta extends z.infer<typeof VersionDelta> {
+}
+export declare const SchemaFile: z.ZodObject<{
+    format: z.ZodLiteral<0>;
+    versions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+            columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+        }, z.core.$strict>>;
+        indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+        delta: z.ZodLiteral<false>;
+    }, z.core.$strict>, 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;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+        }, z.core.$strict>>>>;
+        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;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, 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>;
+                default: z.ZodOptional<z.ZodString>;
+                ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
+            }, z.core.$strict>>>>;
+            add_constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+            drop_constraints: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>>;
+        add_indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+        drop_indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`${string}:${string}`>>>>;
+    }, z.core.$strict>], "delta">>;
+    wipe: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    latest: z.ZodOptional<z.ZodNumber>;
+    acl_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+export interface SchemaFile extends z.infer<typeof SchemaFile> {
+}
+export declare function getSchemaFiles(): Generator<[string, SchemaFile]>;
 /**
- * Expected column types for a table in the database.
+ * Get the active schema
  */
-export type ColumnTypes<TableSchema extends object> = {
-    [K in keyof TableSchema & string]: {
-        type: string;
-        required?: boolean;
-        hasDefault?: boolean;
-    };
-};
-type _Expected = {
-    [K in keyof Schema & string]: ColumnTypes<Schema[K]>;
-};
-export interface ExpectedSchema extends _Expected {
+export declare function getFullSchema(opt?: {
+    exclude?: string[];
+}): SchemaDecl;
+export declare const UpgradesInfo: z.ZodObject<{
+    current: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodInt>>;
+    upgrades: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodCoercedDate<unknown>;
+        from: z.ZodRecord<z.ZodString, z.ZodInt>;
+        to: z.ZodRecord<z.ZodString, z.ZodInt>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export interface UpgradesInfo extends z.infer<typeof UpgradesInfo> {
 }
-export declare const expectedTypes: ExpectedSchema;
+export declare function getUpgradeInfo(): UpgradesInfo;
+export declare function setUpgradeInfo(info: UpgradesInfo): void;
+export declare function applyTableDeltaToSchema(table: Table, delta: TableDelta): void;
+export declare function applyDeltaToSchema(schema: SchemaDecl, delta: VersionDelta): void;
+export declare function validateDelta(delta: VersionDelta): void;
+export declare function computeDelta(from: SchemaDecl, to: SchemaDecl): VersionDelta;
+export declare function collapseDeltas(deltas: VersionDelta[]): VersionDelta;
+export declare function deltaIsEmpty(delta: VersionDelta): boolean;
+export declare function displayDelta(delta: VersionDelta): Generator<string>;
+export declare function applyDelta(delta: VersionDelta, forceAbort?: boolean): Promise<void>;
 export interface CheckOptions extends OpOptions {
     /** Whether to throw an error instead of emitting a warning on most column issues */
     strict?: boolean;
@@ -126,16 +524,6 @@ export interface CheckOptions extends OpOptions {
 /**
  * Checks that a table has the expected column types, nullability, and default values.
  */
-export declare function checkTableTypes<TB extends keyof Schema & string>(tableName: TB, types: ColumnTypes<Schema[TB]>, opt: CheckOptions): Promise<void>;
-export declare function check(opt: CheckOptions): Promise<void>;
+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>;
-/**
- * Completely remove Axium from the database.
- */
-export declare function uninstall(opt: OpOptions): Promise<void>;
-/**
- * Removes all data from tables.
- */
-export declare function wipe(opt: OpOptions): Promise<void>;
 export declare function rotatePassword(): Promise<void>;
-export {};