@primate/core 0.5.0 → 0.6.0

package/lib/private/i18n/module.d.ts

@@ -0,0 +1,3 @@
+import type Config from "#i18n/Config";
+export default function i18n_module(config: Config): import("#module/create").Created;
+//# sourceMappingURL=module.d.ts.map

package/lib/private/i18n/module.js

@@ -0,0 +1,115 @@
+import cookie from "#cookie";
+import COOKIE_NAME from "#i18n/constant/COOKIE_NAME";
+import PERSIST_HEADER from "#i18n/constant/PERSIST_HEADER";
+import E from "#i18n/errors";
+import storage from "#i18n/storage";
+import create from "#module/create";
+import { Status } from "@rcompat/http";
+function toLowerCase(string) {
+    return string.toLowerCase();
+}
+function pick(client, server) {
+    const lower = server.map(toLowerCase);
+    for (const raw of client.map(toLowerCase)) {
+        const locale = raw.trim();
+        if (!locale)
+            continue;
+        const exact = lower.indexOf(locale);
+        if (exact !== -1)
+            return server[exact];
+        const base = locale.split("-")[0];
+        const index = lower.findIndex(s => s === base || s.startsWith(`${base}-`));
+        if (index !== -1)
+            return server[index];
+    }
+    return undefined;
+}
+export default function i18n_module(config) {
+    const default_locale = config.defaultLocale;
+    const locales = Object.keys(config.locales);
+    const persist = config.persist ?? "cookie";
+    const currency = config.currency ?? "USD";
+    let secure = false;
+    if (locales.length < 1)
+        throw E.at_least_one_locale();
+    if (default_locale === undefined)
+        throw E.missing_default_locale(locales);
+    if (!locales.includes(default_locale)) {
+        throw E.unused_default_locale(default_locale, locales);
+    }
+    return create({
+        name: "builtin/i18n",
+        setup({ onServe, onHandle, onRoute }) {
+            onServe(app => {
+                secure = app.secure;
+            });
+            onHandle(async (request, next) => {
+                const requested = request.headers.try(PERSIST_HEADER);
+                if (requested === undefined) {
+                    const locale = request.cookies.try(COOKIE_NAME);
+                    if (locale === undefined)
+                        return next(request);
+                    // if has cookie, run route with i18n
+                    return await new Promise((resolve, reject) => {
+                        storage().run({ locale }, async () => {
+                            try {
+                                resolve(await next(request));
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        });
+                    });
+                }
+                // only cookie-persistance is server-supported
+                if (persist !== "cookie")
+                    return new Response(null, {
+                        headers: {
+                            "Content-Length": String(0),
+                        },
+                        status: Status.NO_CONTENT,
+                    });
+                // only accept existing locales
+                if (!locales.includes(requested))
+                    return new Response(null, {
+                        headers: {
+                            "Content-Length": String(0),
+                        },
+                        status: Status.NO_CONTENT,
+                    });
+                const header = cookie(COOKIE_NAME, requested, {
+                    secure,
+                    path: "/",
+                    sameSite: "Strict",
+                });
+                return new Response(null, {
+                    headers: {
+                        "Set-Cookie": header,
+                        "Content-Length": String(0),
+                    },
+                    status: Status.NO_CONTENT,
+                });
+            });
+            onRoute((request, next) => {
+                const accept_language = request.headers.try("Accept-Language") ?? "";
+                const client_locales = accept_language
+                    .split(",")
+                    .map(s => s.split(";")[0].trim())
+                    .filter(Boolean);
+                const cookie_locale = persist === "cookie"
+                    ? request.cookies.try(COOKIE_NAME)
+                    : undefined;
+                const locale = cookie_locale ??
+                    pick(client_locales, locales) ??
+                    default_locale;
+                return next(request.set("i18n", {
+                    currency,
+                    mode: persist,
+                    locale,
+                    locales,
+                }));
+            });
+        },
+    });
+}
+//# sourceMappingURL=module.js.map

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

@@ -1,8 +1,13 @@
-declare const _default: import("pema").ObjectType<{
-    defaultLocale: import("pema").StringType;
-    locales: import("pema").RecordType<import("pema").StringType, import("pema").UnknownType>;
-    currency: import("pema").DefaultType<import("pema").StringType, "USD">;
-    persist: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"cookie">, import("pema").LiteralType<"localStorage">, import("pema").LiteralType<"sessionStorage">, import("pema").LiteralType<false>]>, false | "cookie" | "localStorage" | "sessionStorage">;
+declare const _default: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly defaultLocale: import("pema").StringType;
+    readonly locales: import("pema").RecordType<import("pema").StringType, import("pema").UnknownType>;
+    readonly currency: import("pema").DefaultType<import("pema").StringType, "USD">;
+    readonly persist: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"cookie">, import("pema").LiteralType<"localStorage">, import("pema").LiteralType<"sessionStorage">, import("pema").LiteralType<false>]>, false | "cookie" | "localStorage" | "sessionStorage">;
+}>, {
+    defaultLocale: string;
+    locales: Record<string, unknown>;
+    currency: string;
+    persist: false | "cookie" | "localStorage" | "sessionStorage";
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/i18n/validate.js

@@ -1,3 +1,4 @@
+import E from "#i18n/errors";
 import is from "@rcompat/is";
 export default function validate(key, locale, path = "") {
     if (Array.isArray(key)) {
@@ -9,13 +10,10 @@ export default function validate(key, locale, path = "") {
     if (!is.dict(key))
         return;
     for (const [k, v] of Object.entries(key)) {
-        if (k.includes(".")) {
-            const at = path ? `${path}.${k}` : k;
-            throw new Error("[i18n] Dots are not allowed in catalog key names. " +
-                `Found "${k}" at "${at}" (locale "${locale}").`);
-        }
-        const next = path ? `${path}.${k}` : k;
-        validate(v, locale, next);
+        const at = path ? `${path}.${k}` : k;
+        if (k.includes("."))
+            throw E.no_dots_catalog_keys(k, at, locale);
+        validate(v, locale, at);
     }
 }
 //# sourceMappingURL=validate.js.map

package/lib/private/index.d.ts

@@ -0,0 +1,14 @@
+export type { default as App } from "#App";
+export type { default as BuildApp } from "#build/App";
+export type { default as Mode } from "#Mode";
+export type { default as Module } from "#Module";
+export type { BuildHook, HandleHook, InitHook, RouteHook, ServeHook, default as Setup } from "#module/Setup";
+export type { default as RequestBag } from "#request/RequestBag";
+export type { default as RequestBody } from "#request/RequestBody";
+export type { default as RequestFacade } from "#request/RequestFacade";
+export type { default as RequestPublic } from "#request/RequestPublic";
+export type { default as RequestView } from "#request/RequestView";
+export type { default as RequestVerb } from "#request/Verb";
+export type { default as ServeApp } from "#serve/App";
+export type { default as Target } from "#target/Target";
+//# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

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

package/lib/private/log.js

@@ -1,8 +1,8 @@
-import AppError from "#AppError";
-import args from "@rcompat/args";
 import color from "@rcompat/cli/color";
 import mark from "@rcompat/cli/mark";
 import print from "@rcompat/cli/print";
+import { CodeError } from "@rcompat/error";
+import runtime from "@rcompat/runtime";
 import p from "pema";
 const levels = {
     error: 0,
@@ -10,7 +10,7 @@ const levels = {
     warn: 1,
 };
 const flag = "--log=";
-const n = args.find(arg => arg.startsWith(flag))?.slice(flag.length);
+const n = runtime.args.find(arg => arg.startsWith(flag))?.slice(flag.length);
 const vn = p.union(...Object.keys(levels)).optional().parse(n);
 class Log {
     #level;
@@ -34,8 +34,9 @@ class Log {
         }
     }
     error(error) {
-        if (error instanceof AppError) {
-            print(color.red("[ERROR]"), error.message, "\n");
+        if (CodeError.is(error)) {
+            const message = error.strings.reduce((acc, str, i) => acc + (i > 0 ? color.bold(String(error.params[i - 1])) : "") + str, "");
+            print(color.red("[ERROR]"), message, "\n");
         }
         else {
             console.error(error);

package/lib/private/module/Setup.d.ts

@@ -0,0 +1,21 @@
+import type App from "#App";
+import type BuildApp from "#build/App";
+import type NextHandle from "#module/NextHandle";
+import type NextRoute from "#module/NextRoute";
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+import type ServeApp from "#serve/App";
+import type { MaybePromise } from "@rcompat/type";
+export type InitHook = (app: App) => MaybePromise<void>;
+export type BuildHook = (app: BuildApp) => MaybePromise<void>;
+export type ServeHook = (app: ServeApp) => MaybePromise<void>;
+export type HandleHook = (request: RequestFacade, next: NextHandle) => MaybePromise<Response>;
+export type RouteHook = (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>;
+export default interface Setup {
+    onInit(hook: InitHook): void;
+    onBuild(hook: BuildHook): void;
+    onServe(hook: ServeHook): void;
+    onHandle(hook: HandleHook): void;
+    onRoute(hook: RouteHook): void;
+}
+//# sourceMappingURL=Setup.d.ts.map

package/lib/private/module/Setup.js

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

package/lib/private/module/create.d.ts

@@ -0,0 +1,16 @@
+import type Module from "#Module";
+import type { BuildHook, HandleHook, InitHook, RouteHook, ServeHook } from "#module/Setup";
+type Hooks = {
+    init: InitHook[];
+    build: BuildHook[];
+    serve: ServeHook[];
+    handle: HandleHook[];
+    route: RouteHook[];
+};
+type Created = {
+    name: string;
+    hooks: Hooks;
+};
+export type { Created, Hooks };
+export default function create({ name, setup }: Module): Created;
+//# sourceMappingURL=create.d.ts.map

package/lib/private/module/create.js

@@ -0,0 +1,28 @@
+export default function create({ name, setup }) {
+    const hooks = {
+        init: [],
+        build: [],
+        serve: [],
+        handle: [],
+        route: [],
+    };
+    setup({
+        onInit(hook) {
+            hooks.init.push(hook);
+        },
+        onBuild(hook) {
+            hooks.build.push(hook);
+        },
+        onServe(hook) {
+            hooks.serve.push(hook);
+        },
+        onHandle(hook) {
+            hooks.handle.push(hook);
+        },
+        onRoute(hook) {
+            hooks.route.push(hook);
+        },
+    });
+    return { name, hooks };
+}
+//# sourceMappingURL=create.js.map

package/lib/private/orm/ExtractSchema.d.ts

@@ -0,0 +1,9 @@
+import type ForeignKey from "#orm/ForeignKey";
+import type PrimaryKey from "#orm/PrimaryKey";
+import type StoreInput from "#orm/StoreInput";
+import type { DataKey, Storable } from "pema";
+type ExtractSchema<T extends StoreInput> = {
+    [K in keyof T]: T[K] extends PrimaryKey<infer P> ? P : T[K] extends ForeignKey<infer P> ? P : T[K] extends Storable<DataKey> ? T[K] : never;
+};
+export type { ExtractSchema as default };
+//# sourceMappingURL=ExtractSchema.d.ts.map

package/lib/private/orm/ExtractSchema.js

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

package/lib/private/orm/ForeignKey.d.ts

@@ -1,7 +1,10 @@
-import type { DataKey, Storable } from "pema";
-export default class ForeignKey<T extends Storable<DataKey>> {
+import type { AllowedPKType } from "#orm/PrimaryKey";
+import type { OptionalType } from "pema";
+export type AllowedFKType = AllowedPKType | OptionalType<AllowedPKType>;
+export default class ForeignKey<T extends AllowedFKType> {
     #private;
     constructor(type: T);
+    static new<T extends AllowedFKType>(type: T): ForeignKey<T>;
     get type(): T;
     get datatype(): keyof import("pema").DataType;
     get name(): string;

package/lib/private/orm/ForeignKey.js

@@ -3,6 +3,9 @@ export default class ForeignKey {
     constructor(type) {
         this.#type = type;
     }
+    static new(type) {
+        return new ForeignKey(type);
+    }
     get type() {
         return this.#type;
     }

package/lib/private/orm/PrimaryKey.d.ts

@@ -1,12 +1,14 @@
-import type { DataKey, Storable } from "pema";
+import type { Storable } from "pema";
 export type Options = {
     generate?: boolean;
 };
-export default class PrimaryKey<T extends Storable<DataKey>> {
+export type AllowedPKType = Storable<"uuid"> | Storable<"uuid_v4"> | Storable<"uuid_v7"> | Storable<"u8"> | Storable<"u16"> | Storable<"u32"> | Storable<"u64"> | Storable<"u128">;
+export default class PrimaryKey<T extends AllowedPKType> {
     #private;
     constructor(type: T, options?: Options);
+    static new<T extends AllowedPKType>(type: T, options?: Options): PrimaryKey<T>;
     get type(): T;
-    get datatype(): keyof import("pema").DataType;
+    get datatype(): "uuid" | "uuid_v4" | "uuid_v7" | "u128" | "u16" | "u32" | "u64" | "u8";
     get name(): string;
     get nullable(): boolean;
     get generate(): boolean;

package/lib/private/orm/PrimaryKey.js

@@ -1,6 +1,7 @@
-import log from "#log";
-const RECOMMENDED_TYPES = new Set([
-    "string", "u16", "u32", "u64", "u128",
+import E from "#db/errors";
+const ALLOWED_TYPES = new Set([
+    "uuid", "uuid_v4", "uuid_v7",
+    "u8", "u16", "u32", "u64", "u128",
 ]);
 export default class PrimaryKey {
     #type;
@@ -9,9 +10,11 @@ export default class PrimaryKey {
         this.#type = type;
         this.#generate = options?.generate ?? true;
         const datatype = this.#type.datatype;
-        if (!RECOMMENDED_TYPES.has(datatype)) {
-            log.warn("key.primary: {0} is unusual for a primary key", datatype);
-        }
+        if (!ALLOWED_TYPES.has(datatype))
+            throw E.pk_invalid_type(datatype);
+    }
+    static new(type, options) {
+        return new PrimaryKey(type, options);
     }
     get type() {
         return this.#type;

package/lib/private/orm/StoreInput.d.ts

@@ -0,0 +1,10 @@
+import type ForeignKey from "#orm/ForeignKey";
+import type { AllowedFKType } from "#orm/ForeignKey";
+import type PrimaryKey from "#orm/PrimaryKey";
+import type { AllowedPKType } from "#orm/PrimaryKey";
+import type { Dict } from "@rcompat/type";
+import type { DataKey, Storable } from "pema";
+type StoreField = Storable<DataKey> | PrimaryKey<AllowedPKType> | ForeignKey<AllowedFKType>;
+type StoreInput = Dict<StoreField>;
+export type { StoreInput as default };
+//# sourceMappingURL=StoreInput.d.ts.map

package/lib/private/orm/StoreInput.js

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

package/lib/private/orm/key.d.ts

@@ -1,8 +1,8 @@
-import foreign from "#orm/foreign";
-import primary from "#orm/primary";
-declare const _default: {
-    primary: typeof primary;
-    foreign: typeof foreign;
+import ForeignKey from "#orm/ForeignKey";
+import PrimaryKey from "#orm/PrimaryKey";
+declare const key: {
+    foreign: typeof ForeignKey.new;
+    primary: typeof PrimaryKey.new;
 };
-export default _default;
+export default key;
 //# sourceMappingURL=key.d.ts.map

package/lib/private/orm/key.js

@@ -1,4 +1,8 @@
-import foreign from "#orm/foreign";
-import primary from "#orm/primary";
-export default { primary, foreign };
+import ForeignKey from "#orm/ForeignKey";
+import PrimaryKey from "#orm/PrimaryKey";
+const key = {
+    foreign: ForeignKey.new,
+    primary: PrimaryKey.new,
+};
+export default key;
 //# sourceMappingURL=key.js.map

package/lib/private/orm/parse.d.ts

@@ -1,12 +1,13 @@
+import type PK from "#db/PK";
 import ForeignKey from "#orm/ForeignKey";
-import type { StoreInput } from "#orm/types";
+import type { AllowedFKType } from "#orm/ForeignKey";
+import type StoreInput from "#orm/StoreInput";
 import type { Dict } from "@rcompat/type";
 import type { Storable } from "pema";
-import type PK from "#db/PK";
 export default function parse(input: StoreInput): {
     pk: PK;
     generate_pk: boolean;
-    fks: Map<string, ForeignKey<Storable<keyof import("pema").DataType>>>;
-    schema: Dict<Storable<keyof import("pema").DataType>>;
+    fks: Map<string, ForeignKey<AllowedFKType>>;
+    schema: Dict<Storable<keyof import("pema").DataType, unknown>>;
 };
 //# sourceMappingURL=parse.d.ts.map

package/lib/private/orm/parse.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#db/errors";
 import ForeignKey from "#orm/ForeignKey";
 import PrimaryKey from "#orm/PrimaryKey";
 const is_pk = (x) => x instanceof PrimaryKey;
@@ -11,7 +11,7 @@ export default function parse(input) {
     for (const [key, value] of Object.entries(input)) {
         if (is_pk(value)) {
             if (pk !== null)
-                throw fail("multiple primary keys: {0}, {1}", pk, key);
+                throw E.pk_multiple_pks(pk, key);
             pk = key;
             generate_pk = value.generate;
             schema[key] = value.type;

package/lib/private/orm/relation.d.ts

@@ -1,5 +1,5 @@
-import type Store from "#orm/Store";
-import type { StoreInput } from "#orm/types";
+import type { Store } from "#orm/store";
+import type StoreInput from "#orm/StoreInput";
 /**
  * extracts schema type from either a schema or a Store.
  */

package/lib/private/orm/{Store.d.ts → store.d.ts}

@@ -1,16 +1,19 @@
 import type DB from "#db/DB";
-import wrap from "#db/symbol/wrap";
+import type PK from "#db/PK";
 import type Types from "#db/Types";
+import type ExtractSchema from "#orm/ExtractSchema";
 import type PrimaryKey from "#orm/PrimaryKey";
 import type { ManyRelation, OneRelation, Relation } from "#orm/relation";
-import type $Set from "#orm/Set";
-import type { ExtractSchema, InferRecord, Insertable, PrimaryKeyField, StoreInput } from "#orm/types";
+import type StoreInput from "#orm/StoreInput";
 import type { Dict, EmptyObject, Serializable } from "@rcompat/type";
-import type { Storable } from "pema";
+import type { DefaultType, InferStore, Storable } from "pema";
 import StoreType from "pema/StoreType";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
+type OrNull<T> = {
+    [P in keyof T]?: null | T[P];
+};
 type StringOperators = {
     $like?: string;
     $ilike?: string;
@@ -35,19 +38,28 @@ type DateOperators = {
     $ne?: Date;
 };
 type QueryOperators<T> = T extends string ? (T | StringOperators | null) : T extends number ? (T | NumberOperators | null) : T extends bigint ? (T | BigIntOperators | null) : T extends Date ? (T | DateOperators | null) : (T | null);
+type InferRecord<T extends StoreInput> = InferStore<ExtractSchema<T>>;
 type Schema<T extends StoreInput> = X<InferRecord<T>>;
 type Where<T extends StoreInput> = X<{
     [K in keyof Schema<T>]?: QueryOperators<Schema<T>[K]>;
 }>;
+type $Set<T extends StoreInput> = X<OrNull<InferStore<ExtractSchema<T>>>>;
 type SelectKey<T> = Extract<keyof T, string>;
 type Select<T> = readonly SelectKey<T>[];
 type Sort<T> = Partial<Record<SelectKey<T>, "asc" | "desc">>;
 type Projected<T, S extends Select<T> | undefined> = S extends readonly (keyof T)[] ? X<Pick<T, S[number]>> : T;
+type DefaultFields<T extends StoreInput> = {
+    [K in keyof InferRecord<T>]: T[K] extends DefaultType<any, any> ? K : never;
+}[keyof InferRecord<T>];
+type Insertable<T extends StoreInput> = Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Partial<Pick<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>>>;
+type PrimaryKeyField<T extends StoreInput> = {
+    [K in keyof T]: T[K] extends PrimaryKey<any> ? K : never;
+}[keyof T] & keyof InferRecord<T>;
 declare const NUMBER_KEYS: readonly ["u8", "u16", "u32", "i8", "i16", "i32", "f32", "f64"];
 declare const BIGINT_KEYS: readonly ["u64", "u128", "i64", "i128"];
 type NumberKey = typeof NUMBER_KEYS[number];
 type BigIntKey = typeof BIGINT_KEYS[number];
-type PKV<T extends StoreInput> = T[PrimaryKeyField<T>] extends PrimaryKey<infer P> ? P extends Storable<infer D> ? D extends "string" ? string : D extends NumberKey ? number : D extends BigIntKey ? bigint : string | number | bigint : string | number | bigint : string | number | bigint;
+type PKV<T extends StoreInput> = T[PrimaryKeyField<T>] extends PrimaryKey<infer P> ? P extends Storable<infer D> ? D extends "uuid" | "uuid_v4" | "uuid_v7" ? string : D extends NumberKey ? number : D extends BigIntKey ? bigint : string | number | bigint : string | number | bigint : string | number | bigint;
 type WithQuery<T extends StoreInput> = true | {
     where?: Where<T>;
     select?: Select<Schema<T>>;
@@ -65,10 +77,13 @@ type RelationResult<Rel, Q> = Rel extends OneRelation<infer S, string> ? Q exten
 type WithRelations<Base, Relations extends Dict<Relation>, W extends With<Relations> | undefined> = W extends object ? X<Base & {
     [K in keyof W & keyof Relations]: RelationResult<Relations[K], W[K]>;
 }> : Base;
-type Config<R extends Dict<Relation>> = {
-    db?: DB;
-    name?: string;
+type Init<S extends StoreInput, R extends Dict<Relation>> = {
+    name: string;
+    db: DB;
+    schema: S;
     relations?: R;
+    migrate?: boolean;
+    extend?: Dict;
 };
 /**
  * Database-backed store.
@@ -77,22 +92,22 @@ type Config<R extends Dict<Relation>> = {
  * document database table/collection. It pairs a Pema schema with a uniform
  * CRUD/query API.
  */
-export default class Store<T extends StoreInput, R extends Dict<Relation> = EmptyObject> implements Serializable {
+export declare class Store<T extends StoreInput, R extends Dict<Relation> = EmptyObject> implements Serializable {
     #private;
-    [wrap]: (name: string, db: DB) => this;
     readonly Schema: Schema<T>;
-    constructor(input: T, config?: Config<R>);
-    static new<T extends StoreInput, R extends Dict<Relation> = EmptyObject>(input: T, config?: Config<R>): Store<T, R>;
-    get collection(): {
+    constructor(init: Init<T, R>);
+    get table(): {
         create: () => import("@rcompat/type").MaybePromise<void>;
         delete: () => import("@rcompat/type").MaybePromise<void>;
     };
     get infer(): InferRecord<T>;
-    get schema(): Dict<Storable<keyof import("pema").DataType>>;
+    get schema(): Dict<Storable<keyof import("pema").DataType, unknown>>;
     get type(): StoreType<ExtractSchema<T>>;
+    get migrate(): boolean;
+    get name(): string;
+    get pk(): PK;
     get db(): DB;
     get types(): Types;
-    get name(): string;
     /**
      * Count records
      */
@@ -167,5 +182,6 @@ export default class Store<T extends StoreInput, R extends Dict<Relation> = Empt
     };
     extend<A extends Dict>(extensor: (This: this) => A): this & A;
 }
-export {};
-//# sourceMappingURL=Store.d.ts.map
+declare function store<T extends StoreInput, R extends Dict<Relation> = EmptyObject>(init: Init<T, R>): Store<T, R>;
+export default store;
+//# sourceMappingURL=store.d.ts.map