@primate/core 0.5.0 → 0.6.0

package/lib/private/client/http.js

@@ -0,0 +1,57 @@
+import { MIME } from "@rcompat/http";
+const sameorigin = (url) => url.origin === globalThis.location.origin;
+const get_location = (response, base) => {
+    if (response.type === "opaqueredirect")
+        return null;
+    const location = response.headers.get("Location");
+    return location !== null ? new URL(location, base) : null;
+};
+async function refetch(input, init = {}, max_hops = 5) {
+    let url = new URL(input.toString(), globalThis.location.href);
+    const method = (init.method ?? "GET").toUpperCase();
+    let hops = 0;
+    if (method !== "GET") {
+        const response = await fetch(url.pathname + url.search, {
+            ...init, redirect: "follow",
+        });
+        return { requested: new URL(response.url), response };
+    }
+    while (hops < max_hops) {
+        const response = await fetch(url.pathname + url.search, {
+            ...init, redirect: "manual",
+        });
+        if (response.type === "opaqueredirect")
+            return { requested: url, response };
+        const location = get_location(response, url.toString());
+        if (location !== null && response.status >= 300 && response.status < 400) {
+            if (!sameorigin(location))
+                return { requested: url, response };
+            url = location;
+            hops++;
+            continue;
+        }
+        return { requested: url, response };
+    }
+    throw new Error("Too many redirects");
+}
+function is_json(response) {
+    const raw = response.headers.get("content-type") ?? "";
+    return raw.split(";")[0].trim() === MIME.APPLICATION_JSON;
+}
+async function submit(pathname, body, method) {
+    const { requested, response } = await refetch(pathname, { body, method });
+    if (is_json(response)) {
+        history.replaceState({}, "", requested.pathname + requested.search);
+    }
+    else {
+        globalThis.location.assign(requested.toString());
+    }
+    return response;
+}
+const http = {
+    refetch,
+    is_json,
+    submit,
+};
+export default http;
+//# sourceMappingURL=http.js.map

package/lib/private/client/index.d.ts

@@ -0,0 +1,23 @@
+import type { FormInit, FormView } from "#client/create-form";
+import createForm from "#client/create-form";
+import type Data from "#client/Data";
+import type Publish from "#client/Publish";
+import type Render from "#client/Render";
+import submit from "#client/submit";
+import toValidated from "#client/to-validated";
+import validateField from "#client/validate-field";
+import type ValidateInit from "#client/ValidateInit";
+import type ValidateUpdater from "#client/ValidateUpdater";
+import type ValidationError from "#client/ValidationError";
+import type ViewResponse from "#client/ViewResponse";
+declare const client: {
+    boot: <T extends import("@rcompat/type").Dict>(u: import("./root.js").Updater<T>) => void;
+    navigate: (href: string, event?: Event) => Promise<void>;
+    submit: typeof submit;
+    createForm: typeof createForm;
+    validateField: typeof validateField;
+    toValidated: typeof toValidated;
+};
+export default client;
+export type { Data, FormInit, FormView, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse, };
+//# sourceMappingURL=index.d.ts.map

package/lib/private/client/index.js

@@ -0,0 +1,16 @@
+import boot from "#client/boot";
+import createForm from "#client/create-form";
+import navigate from "#client/navigate";
+import submit from "#client/submit";
+import toValidated from "#client/to-validated";
+import validateField from "#client/validate-field";
+const client = {
+    boot,
+    navigate: navigate.go,
+    submit,
+    createForm,
+    validateField,
+    toValidated,
+};
+export default client;
+//# sourceMappingURL=index.js.map

package/lib/private/client/navigate.d.ts

@@ -0,0 +1,13 @@
+type Location = {
+    hash: string;
+    pathname: string;
+};
+declare function goto(target: Location, state?: boolean, after?: () => void): Promise<void>;
+declare function go(href: string, event?: Event): Promise<void>;
+declare const navigate: {
+    go: typeof go;
+    goto: typeof goto;
+    scroll_hash: (hash: string) => void;
+};
+export default navigate;
+//# sourceMappingURL=navigate.d.ts.map

package/lib/private/client/navigate.js

@@ -0,0 +1,67 @@
+import http from "#client/http";
+import root from "#client/root";
+import storage from "#client/storage";
+import { MIME } from "@rcompat/http";
+const headers = {
+    Accept: MIME.APPLICATION_JSON,
+};
+const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
+const scroll_hash = (hash) => {
+    if (hash === "") {
+        globalThis.scrollTo(0, 0);
+    }
+    else {
+        get_by_id_or_name(hash.slice(1)).scrollIntoView();
+    }
+};
+async function goto(target, state = false, after) {
+    try {
+        const { scrollTop } = globalThis.document.scrollingElement;
+        const { location } = globalThis;
+        const { requested, response } = await http.refetch(target.pathname, { headers });
+        if (http.is_json(response)) {
+            if (response.ok)
+                root.update(await response.json());
+            if (state) {
+                storage.new({ hash: location.hash, pathname: location.pathname, scrollTop });
+                history.pushState({}, "", `${target.pathname}${target.hash}`);
+            }
+            after?.();
+            return;
+        }
+        const dest = response.type !== "opaqueredirect"
+            ? requested.toString() + target.hash
+            : new URL(target.pathname + target.hash, location.href).toString();
+        location.assign(dest);
+    }
+    catch (error) {
+        console.warn(error);
+    }
+}
+async function go(href, event) {
+    const url = new URL(href);
+    const { hash, pathname } = url;
+    const { location } = globalThis;
+    if (url.host === location.host) {
+        event?.preventDefault();
+        if (location.pathname !== pathname) {
+            await goto(url, true, () => {
+                scroll_hash(hash);
+                globalThis.dispatchEvent(new Event("updated"));
+            });
+        }
+        if (location.hash !== hash) {
+            const { scrollTop } = globalThis.document.scrollingElement;
+            storage.new({ hash: location.hash, pathname: location.pathname, scrollTop, stop: true });
+            history.pushState(null, "", `${location.pathname}${hash}`);
+            scroll_hash(hash);
+        }
+    }
+}
+const navigate = {
+    go,
+    goto,
+    scroll_hash,
+};
+export default navigate;
+//# sourceMappingURL=navigate.js.map

package/lib/private/client/root.d.ts

@@ -0,0 +1,9 @@
+import type ClientData from "#client/Data";
+import type { Dict } from "@rcompat/type";
+export type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
+declare const root: {
+    set(updater: Updater<any>): void;
+    update(data: any, after?: () => void): void;
+};
+export default root;
+//# sourceMappingURL=root.d.ts.map

package/lib/private/client/root.js

@@ -0,0 +1,11 @@
+let current;
+const root = {
+    set(updater) {
+        current = updater;
+    },
+    update(data, after) {
+        current(data, after);
+    },
+};
+export default root;
+//# sourceMappingURL=root.js.map

package/lib/private/client/submit.d.ts

@@ -0,0 +1,2 @@
+export default function submit(pathname: string, body: any, method: string): Promise<Response>;
+//# sourceMappingURL=submit.d.ts.map

package/lib/private/client/submit.js

@@ -0,0 +1,41 @@
+import http from "#client/http";
+import root from "#client/root";
+import storage from "#client/storage";
+import { MIME } from "@rcompat/http";
+const headers = {
+    Accept: MIME.APPLICATION_JSON,
+};
+export default async function submit(pathname, body, method) {
+    const { requested, response } = await http.refetch(pathname, {
+        body, headers, method,
+    });
+    if (response.redirected) {
+        const { location, document, history } = globalThis;
+        const scrollTop = document.scrollingElement?.scrollTop ?? 0;
+        if (http.is_json(response))
+            root.update(await response.json());
+        storage.new({
+            hash: location.hash,
+            pathname: location.pathname,
+            scrollTop,
+        });
+        const url = new URL(response.url);
+        history.pushState({}, "", url.pathname + url.search);
+        return response;
+    }
+    if (http.is_json(response)) {
+        if (response.ok) {
+            root.update(await response.json());
+            history.replaceState({}, "", requested.pathname + requested.search);
+        }
+        return response;
+    }
+    if (response.status === 204)
+        return response;
+    const target = response.type !== "opaqueredirect"
+        ? requested.toString()
+        : new URL(pathname, globalThis.location.href).toString();
+    globalThis.location.assign(target);
+    return response;
+}
+//# sourceMappingURL=submit.js.map

package/lib/private/config/index.d.ts

@@ -1,5 +1,10 @@
+import type EnvSchema from "#app/EnvSchema";
 import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-declare const _default: (input?: typeof schema.input) => AppFacade;
-export default _default;
+import type { ObjectType } from "pema";
+export default function config<P extends EnvSchema = EnvSchema>(input?: typeof schema.input & {
+    env?: {
+        schema?: ObjectType<P>;
+    };
+}): AppFacade<P>;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/config/index.js

@@ -1,5 +1,6 @@
 import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-export default (input = {}) => new AppFacade(schema.parse(input));
-;
+export default function config(input = {}) {
+    return new AppFacade(schema.parse(input));
+}
 //# sourceMappingURL=index.js.map

package/lib/private/config/schema.d.ts

@@ -1,29 +1,85 @@
-import Module from "#Module";
-declare const _default: import("pema").ObjectType<{
-    http: import("pema").ObjectType<{
-        csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
-        headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
-        host: import("pema").DefaultType<import("pema").StringType, "localhost">;
-        port: import("pema").DefaultType<import("pema").UintType<"u32">, 6161>;
-        ssl: import("pema").ObjectType<{
-            cert: import("pema").OptionalType<import("pema").UnionType<[import("pema").ConstructorType<typeof import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
-            key: import("pema").OptionalType<import("pema").UnionType<[import("pema").ConstructorType<typeof import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
-        }>;
-        static: import("pema").ObjectType<{
-            root: import("pema").DefaultType<import("pema").StringType, "/">;
-        }>;
-    }>;
-    livereload: import("pema").ObjectType<{
-        exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
-        host: import("pema").OptionalType<import("pema").StringType>;
-        port: import("pema").OptionalType<import("pema").UintType<"u32">>;
-    }>;
-    modules: import("pema").OptionalType<import("pema").ArrayType<import("pema").ConstructorType<typeof Module>>>;
-    request: import("pema").ObjectType<{
-        body: import("pema").ObjectType<{
-            parse: import("pema").DefaultType<import("pema").BooleanType, true>;
-        }>;
-    }>;
+import type DB from "#db/DB";
+import type Module from "#Module";
+import type { Dict } from "@rcompat/type";
+import type { ObjectType, Parsed } from "pema";
+declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly http: {
+        readonly csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
+        readonly headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
+        readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+        readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 6161>;
+        readonly ssl: {
+            readonly cert: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+            readonly key: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+        };
+        readonly static: {
+            readonly root: import("pema").DefaultType<import("pema").StringType, "/">;
+        };
+    };
+    readonly livereload: {
+        readonly exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
+        readonly host: import("pema").OptionalType<import("pema").StringType>;
+        readonly port: import("pema").OptionalType<import("pema").UintType<"u32">>;
+    };
+    readonly db: {
+        readonly migrations: import("pema").OptionalType<ObjectType<{
+            table: import("pema").StringType;
+            db: import("pema").PureType<DB, "PureType">;
+        }, {
+            table: string;
+            db: DB;
+        }>>;
+    };
+    readonly env: {
+        readonly schema: import("pema").OptionalType<import("pema").PureType<ObjectType<Dict<Parsed<unknown>>, {
+            [x: string]: unknown;
+        }>, "PureType">>;
+    };
+    readonly modules: import("pema").DefaultType<import("pema").ArrayType<ObjectType<{
+        name: import("pema").StringType;
+        setup: import("pema").FunctionType;
+    }, Module>>, Module[]>;
+    readonly request: {
+        readonly body: {
+            readonly parse: import("pema").DefaultType<import("pema").BooleanType, true>;
+        };
+    };
+}>, {
+    http: {
+        csp: Record<string, string[]> | undefined;
+        headers: Record<string, string> | undefined;
+        host: string;
+        port: number;
+        ssl: {
+            cert: string | import("@rcompat/fs").FileRef | undefined;
+            key: string | import("@rcompat/fs").FileRef | undefined;
+        };
+        static: {
+            root: string;
+        };
+    };
+    livereload: {
+        exclude: string[] | undefined;
+        host: string | undefined;
+        port: number | undefined;
+    };
+    db: {
+        migrations: {
+            table: string;
+            db: DB;
+        } | undefined;
+    };
+    env: {
+        schema: ObjectType<Dict<Parsed<unknown>>, {
+            [x: string]: unknown;
+        }> | undefined;
+    };
+    modules: Module[];
+    request: {
+        body: {
+            parse: boolean;
+        };
+    };
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/config/schema.js

@@ -1,4 +1,3 @@
-import Module from "#Module";
 import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
@@ -8,8 +7,8 @@ export default p({
         host: p.string.default("localhost"),
         port: p.uint.port().default(6161),
         ssl: {
-            cert: p.union(fs.FileRef, p.string).optional(),
-            key: p.union(fs.FileRef, p.string).optional(),
+            cert: p.union(p.is(fs.isRef), p.string).optional(),
+            key: p.union(p.is(fs.isRef), p.string).optional(),
         },
         static: {
             root: p.string.default("/"),
@@ -20,7 +19,21 @@ export default p({
         host: p.string.optional(),
         port: p.uint.port().optional(),
     },
-    modules: p.array(p.constructor(Module)).optional(),
+    db: {
+        migrations: p.object({
+            table: p.string,
+            db: p.pure(),
+        }).optional(),
+    },
+    env: {
+        schema: p.pure().optional(),
+    },
+    modules: p.array(p.object({
+        name: p.string,
+        setup: p.function,
+    }).shape())
+        .uniqueBy(member => member.name)
+        .default([]),
     request: {
         body: {
             parse: p.boolean.default(true),

package/lib/private/cookie.d.ts

@@ -1,9 +1,15 @@
-declare const Schema: import("pema").ObjectType<{
-    httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
-    path: import("pema").DefaultType<import("pema").StringType, "/">;
-    sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
-    secure: import("pema").BooleanType;
-    maxAge: import("pema").OptionalType<import("pema").NumberType<"f64">>;
+declare const Schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
+    readonly path: import("pema").DefaultType<import("pema").StringType, "/">;
+    readonly sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
+    readonly secure: import("pema").BooleanType;
+    readonly maxAge: import("pema").OptionalType<import("pema").NumberType<"f64">>;
+}>, {
+    httpOnly: boolean;
+    path: string;
+    sameSite: "Lax" | "None" | "Strict";
+    secure: boolean;
+    maxAge: number | undefined;
 }>;
 type Options = typeof Schema.input;
 export default function cookie(name: string, value: string, options: Options): string;

package/lib/private/db/DB.d.ts

@@ -1,13 +1,28 @@
 import type As from "#db/As";
+import type PK from "#db/PK";
 import type Sort from "#db/Sort";
+import type Types from "#db/Types";
 import type With from "#db/With";
 import type { Dict, MaybePromise } from "@rcompat/type";
-import type { StoreSchema } from "pema";
+import type { DataType } from "pema";
+export interface SchemaDiff {
+    add: Types;
+    drop: string[];
+    rename: [string, string][];
+}
+type MaybeTable = Dict<(keyof DataType)[]> | null;
+type PKConfig = {
+    name: PK;
+    generate: boolean;
+};
+export type Schema = {
+    create(name: string, pk: PKConfig, types: Types): MaybePromise<void>;
+    delete(name: string): MaybePromise<void>;
+    introspect(name: string, pk?: PK): MaybePromise<MaybeTable>;
+    alter(name: string, diff: SchemaDiff): MaybePromise<void>;
+};
 export default interface DB {
-    schema: {
-        create(as: As, schema: StoreSchema): MaybePromise<void>;
-        delete(name: string): MaybePromise<void>;
-    };
+    schema: Schema;
     close(): MaybePromise<void>;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
     read(as: As, args: {
@@ -30,4 +45,5 @@ export default interface DB {
         where: Dict;
     }): MaybePromise<number>;
 }
+export {};
 //# sourceMappingURL=DB.d.ts.map

package/lib/private/db/DB.js

@@ -1,2 +1,3 @@
+;
 export {};
 //# sourceMappingURL=DB.js.map

package/lib/private/db/MemoryDB.d.ts

@@ -1,15 +1,13 @@
 import type As from "#db/As";
 import type DB from "#db/DB";
+import type { Schema } from "#db/DB";
 import type DataDict from "#db/DataDict";
 import type Sort from "#db/Sort";
 import type With from "#db/With";
 import type { Dict, MaybePromise } from "@rcompat/type";
 export default class MemoryDB implements DB {
     #private;
-    get schema(): {
-        create: (as: As) => void;
-        delete: (table: string) => void;
-    };
+    get schema(): Schema;
     close(): void;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
     read(as: As, args: {

package/lib/private/db/MemoryDB.js

@@ -1,8 +1,7 @@
-import E from "#db/error";
+import E from "#db/errors";
 import assert from "@rcompat/assert";
 import entries from "@rcompat/dict/entries";
 import is from "@rcompat/is";
-const PK_TYPES = ["string", "bigint", "number"];
 function escape_re(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -123,23 +122,44 @@ function toSorted(d1, d2, sort) {
 }
 export default class MemoryDB {
     #tables = {};
-    #new(as) {
-        if (this.#tables[as.table] !== undefined)
-            return;
-        this.#tables[as.table] = [];
-    }
-    #drop(table) {
-        if (this.#tables[table] !== undefined)
-            delete this.#tables[table];
-    }
+    #types = {};
     #use(name) {
         this.#tables[name] ??= [];
         return this.#tables[name];
     }
     get schema() {
         return {
-            create: this.#new.bind(this),
-            delete: this.#drop.bind(this),
+            create: async (table, _pk, types) => {
+                if (this.#tables[table] !== undefined)
+                    return;
+                this.#tables[table] = [];
+                this.#types[table] = types;
+            },
+            delete: table => {
+                if (this.#tables[table] !== undefined)
+                    delete this.#tables[table];
+            },
+            introspect: table => {
+                if (this.#tables[table] === undefined)
+                    return null;
+                const types = this.#types[table] ?? {};
+                return Object.fromEntries(Object.entries(types).map(([field, type]) => [field, [type]]));
+            },
+            alter: (table, diff) => {
+                if (this.#types[table] === undefined)
+                    throw E.table_not_found(table);
+                const types = { ...this.#types[table] };
+                const { add, drop, rename } = diff;
+                for (const [field, type] of Object.entries(add))
+                    types[field] = type;
+                for (const field of drop)
+                    delete types[field];
+                for (const [from, to] of rename) {
+                    types[to] = types[from];
+                    delete types[from];
+                }
+                this.#types[table] = types;
+            },
         };
     }
     // noop
@@ -149,7 +169,7 @@ export default class MemoryDB {
         const size = table.length;
         const pk = assert.defined(as.pk);
         const type = as.types[pk];
-        if (type === "string") {
+        if (type === "uuid" || type === "uuid_v4" || type === "uuid_v7") {
             return crypto.randomUUID();
         }
         else if (["u64", "u128", "i64", "i128"].includes(type)) {
@@ -160,7 +180,7 @@ export default class MemoryDB {
         }
     }
     create(as, record) {
-        assert.nonempty(record, "empty record");
+        assert.nonempty(record);
         const table = this.#use(as.table);
         const pk = as.pk;
         let to_insert = record;
@@ -170,10 +190,8 @@ export default class MemoryDB {
             to_insert = { ...record, [pk]: this.#next_id(as) };
         }
         if (pk !== null) {
-            const pkv = to_insert[pk];
-            if (!PK_TYPES.includes(typeof pkv))
-                throw E.pk_invalid(pkv);
-            if (table.find(stored => stored[pk] === pkv))
+            const pv = to_insert[pk];
+            if (table.find(s => s[pk] === pv) !== undefined)
                 throw E.pk_duplicate(pk);
         }
         table.push({ ...to_insert });
@@ -239,7 +257,7 @@ export default class MemoryDB {
                     }
                     // filter by target_pk equality + optional where
                     let candidates = target.filter(t => t[target_pk] === fk_value && match(t, r_where));
-                    if (r_sort && Object.keys(r_sort).length > 0) {
+                    if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
                         candidates = candidates.toSorted((a, b) => toSorted(a, b, r_sort));
                     }
                     if (r_limit !== undefined)
@@ -262,7 +280,7 @@ export default class MemoryDB {
                 if (!match(row, r_where))
                     continue;
                 const bucket = grouped.get(key);
-                if (bucket)
+                if (bucket !== undefined)
                     bucket.push(row);
                 else
                     grouped.set(key, [row]);
@@ -271,7 +289,7 @@ export default class MemoryDB {
                 const parent_full = base_full[i];
                 const key = parent_full[parent_pk];
                 let rows = grouped.get(key) ?? [];
-                if (r_sort && Object.keys(r_sort).length > 0) {
+                if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
                     rows = rows.toSorted((a, b) => toSorted(a, b, r_sort));
                 }
                 if (kind === "one") {

package/lib/private/db/common.d.ts

@@ -3,6 +3,10 @@ import type ReadArgs from "#db/ReadArgs";
 import type ReadRelationsArgs from "#db/ReadRelationsArgs";
 import type With from "#db/With";
 import type { Dict } from "@rcompat/type";
+import type { DataKey } from "pema";
+declare const UUID_TYPES: DataKey[];
+declare function generate_uuid(type: typeof UUID_TYPES[number]): string;
+declare function is_uuid_type(type: DataKey): type is typeof UUID_TYPES[number];
 declare const BASE: {
     withed(args: ReadArgs & {
         with?: With;
@@ -10,9 +14,12 @@ declare const BASE: {
     fields(base: string[] | undefined, ...add: (string | null)[]): string[] | undefined;
     project(row: Dict, fields?: string[]): Dict;
     expand(as: As, fields: string[] | undefined, relations: With): string[] | undefined;
+    generate_uuid: typeof generate_uuid;
+    is_uuid_type: typeof is_uuid_type;
     BIGINT_STRING_TYPES: string[];
     UNSIGNED_BIGINT_TYPES: string[];
     INT_TYPES: string[];
+    UUID_TYPES: (keyof import("pema").DataType)[];
 };
 export default BASE;
 //# sourceMappingURL=common.d.ts.map