@evolu/common 5.4.8 → 6.0.0

package/dist/src/Evolu/Evolu.js

@@ -0,0 +1,434 @@
+import { isNonEmptyArray, isNonEmptyReadonlyArray } from "../Array.js";
+import { assertNonEmptyArray } from "../Assert.js";
+import { createCallbacks } from "../Callbacks.js";
+import { exhaustiveCheck } from "../Function.js";
+import { err, ok } from "../Result.js";
+import { isSqlMutation } from "../Sqlite.js";
+import { createStore } from "../Store.js";
+import { createId, } from "../Type.js";
+import { defaultConfig } from "./Config.js";
+import { applyPatches } from "./Diff.js";
+import { kysely } from "./Kysely.js";
+import { createSubscribedQueries, emptyRows, serializeQuery, } from "./Query.js";
+import { assertValidEvoluSchema, insertable, updateable, upsertable, validEvoluSchemaToDbSchema, } from "./Schema.js";
+import { initialSyncState } from "./Sync.js";
+// For hot reloading and Evolu multitenancy.
+const evoluInstances = new Map();
+let tabId = null;
+/**
+ * Creates an {@link Evolu} instance configured with the specified
+ * {@link EvoluSchema} and optional configuration.
+ *
+ * This function returns a configured Evolu instance, providing a typed
+ * interface for querying, mutating, and syncing your application's data. The
+ * returned instance includes:
+ *
+ * - Subscription methods for receiving updates on queries, the owner, errors, and
+ *   sync state.
+ * - Methods for creating, updating, or deleting rows in a type-safe manner.
+ * - Methods for querying data using Evolu's typed SQL queries, leveraging Kysely
+ *   under the hood.
+ * - Built-in support for local-first and offline-first data with automatic sync
+ *   and merging.
+ * - Automatic schema evolution that updates the underlying database with new
+ *   columns or tables.
+ * - Managing owner data with resetAppOwner and restoreAppOwner.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const TodoId = id("Todo");
+ * type TodoId = InferType<typeof TodoId>;
+ *
+ * const TodoCategoryId = id("TodoCategory");
+ * type TodoCategoryId = InferType<typeof TodoCategoryId>;
+ *
+ * const NonEmptyString50 = maxLength(50, NonEmptyString);
+ * type NonEmptyString50 = InferType<typeof NonEmptyString50>;
+ *
+ * const Schema = {
+ *   todo: {
+ *     id: TodoId,
+ *     title: NonEmptyString1000,
+ *     isCompleted: nullOr(SqliteBoolean),
+ *     categoryId: nullOr(TodoCategoryId),
+ *   },
+ *   todoCategory: {
+ *     id: TodoCategoryId,
+ *     name: NonEmptyString50,
+ *   },
+ * };
+ *
+ * const evolu = createEvolu(evoluReactDeps)(Schema);
+ * ```
+ */
+export const createEvolu = (deps) => (
+// TODO: Validate missing Id, unsupported types, used default types via TS types
+// with type errors messages as we had it in the old Evolu.
+schema, partialConfig = {}) => {
+    const config = { ...defaultConfig, ...partialConfig };
+    let evolu = evoluInstances.get(config.name);
+    if (evolu == null) {
+        evolu = createEvoluInstance(deps)(schema, config);
+        evoluInstances.set(config.name, evolu);
+    }
+    else {
+        // Hot reloading. Note that indexes are intentionally omitted.
+        evolu.ensureSchema(schema);
+    }
+    return evolu;
+};
+const createEvoluInstance = (deps) => (schema, evoluConfig) => {
+    deps.console.enabled = evoluConfig.enableLogging ?? false;
+    deps.console.log("[evolu]", "createEvoluInstance");
+    const { initialData, indexes, ...config } = evoluConfig;
+    const errorStore = createStore(null);
+    const rowsStore = createStore(new Map());
+    const ownerStore = createStore(null);
+    const syncStore = createStore(initialSyncState);
+    const subscribedQueries = createSubscribedQueries(rowsStore);
+    const loadingPromises = createLoadingPromises(subscribedQueries);
+    const callbacks = createCallbacks(deps);
+    const appState = deps.createAppState(config);
+    const dbWorker = deps.createDbWorker(config.name);
+    const getTabId = () => {
+        tabId ??= createId(deps);
+        return tabId;
+    };
+    dbWorker.onMessage((message) => {
+        switch (message.type) {
+            case "onInit": {
+                ownerStore.set(message.owner);
+                break;
+            }
+            case "onError": {
+                errorStore.set(message.error);
+                break;
+            }
+            case "onChange": {
+                if (message.tabId !== getTabId())
+                    return;
+                const state = rowsStore.get();
+                const nextState = new Map([
+                    ...state,
+                    ...message.patches.map(({ query, patches }) => [
+                        query,
+                        applyPatches(patches, state.get(query) ?? emptyRows),
+                    ]),
+                ]);
+                for (const { query } of message.patches) {
+                    loadingPromises.resolve(query, nextState.get(query) ?? emptyRows);
+                }
+                if (deps.flushSync && message.onCompleteIds.length > 0) {
+                    deps.flushSync(() => {
+                        rowsStore.set(nextState);
+                    });
+                }
+                else {
+                    rowsStore.set(nextState);
+                }
+                for (const id of message.onCompleteIds) {
+                    callbacks.execute(id);
+                }
+                break;
+            }
+            case "onReceive": {
+                if (message.tabId && message.tabId === getTabId())
+                    return;
+                loadingPromises.releaseUnsubscribed();
+                const queries = subscribedQueries.get();
+                if (isNonEmptyReadonlyArray(queries)) {
+                    dbWorker.postMessage({ type: "query", tabId: getTabId(), queries });
+                }
+                break;
+            }
+            case "onReset": {
+                if (message.reload) {
+                    appState.reset();
+                }
+                else {
+                    callbacks.execute(message.onCompleteId);
+                }
+                break;
+            }
+            case "onExport": {
+                callbacks.execute(message.onCompleteId, message.file);
+                break;
+            }
+            default:
+                exhaustiveCheck(message);
+        }
+    });
+    const dbSchema = validEvoluSchemaToDbSchema(assertValidEvoluSchema(schema), indexes);
+    const mutationTypesCache = new Map();
+    // Lazy create mutation Types like this: `insertable(Schema.todo)`
+    const getMutationType = (table, kind) => {
+        let types = mutationTypesCache.get(kind);
+        if (!types) {
+            types = new Map();
+            mutationTypesCache.set(kind, types);
+        }
+        let type = types.get(table);
+        if (!type) {
+            type = { insert: insertable, update: updateable, upsert: upsertable }[kind](schema[table]);
+            types.set(table, type);
+        }
+        return type;
+    };
+    const initialDataDbChanges = [];
+    /**
+     * Note that the initial data function is called even if it is unnecessary
+     * (initial data are already in the DB) because we don't want to wait for
+     * SQLite's response. Initial data should be small (because they are inlined
+     * in the code), so it's ok.
+     */
+    if (initialData)
+        initialData({
+            insert: (table, props) => {
+                const Type = getMutationType(table, "insert");
+                const id = createId(deps);
+                const result = Type.fromUnknown(props);
+                if (result.ok) {
+                    initialDataDbChanges.push({
+                        id,
+                        table,
+                        values: result.value,
+                    });
+                    return ok({ id });
+                }
+                return result;
+            },
+        });
+    dbWorker.postMessage({
+        type: "init",
+        config,
+        dbSchema,
+        initialData: initialDataDbChanges,
+    });
+    const loadQueryMicrotaskQueue = [];
+    const mutateMicrotaskQueue = [];
+    const createMutation = (kind) => (table, props, options) => {
+        const Type = getMutationType(table, kind);
+        const result = Type.fromUnknown(props);
+        const id = kind === "insert"
+            ? createId(deps)
+            : props.id;
+        if (options?.onlyValidate !== true) {
+            if (!result.ok) {
+                // One error must invalidate the whole queue.
+                // We insert `undefined` to detect such a situation.
+                mutateMicrotaskQueue.push([undefined, undefined]);
+            }
+            else {
+                // Remove `id` from values.
+                const { id: _id, ...values } = result.value;
+                // EvoluSchema Types ensure valid types.
+                const change = { table, id, values };
+                mutateMicrotaskQueue.push([change, options?.onComplete]);
+            }
+            if (mutateMicrotaskQueue.length === 1)
+                queueMicrotask(() => {
+                    const changes = [];
+                    const onCompletes = [];
+                    for (const [change, onComplete] of mutateMicrotaskQueue) {
+                        if (change)
+                            changes.push(change);
+                        if (onComplete)
+                            onCompletes.push(onComplete);
+                    }
+                    const mutateMicrotaskQueueLength = mutateMicrotaskQueue.length;
+                    mutateMicrotaskQueue.length = 0;
+                    // Don't mutate anything if there was a validation error.
+                    // All mutations within a queue are considered to be a transaction.
+                    if (changes.length !== mutateMicrotaskQueueLength) {
+                        return;
+                    }
+                    const onCompleteIds = onCompletes.map((onComplete) => callbacks.register(onComplete));
+                    loadingPromises.releaseUnsubscribed();
+                    if (isNonEmptyArray(changes))
+                        dbWorker.postMessage({
+                            type: "mutate",
+                            tabId: getTabId(),
+                            changes,
+                            onCompleteIds,
+                            subscribedQueries: subscribedQueries.get(),
+                        });
+                });
+        }
+        if (result.ok)
+            return ok({ id });
+        return err(result.error);
+    };
+    const evolu = {
+        subscribeError: errorStore.subscribe,
+        getError: errorStore.get,
+        createQuery: (queryCallback, options) => {
+            const compiledQuery = queryCallback(kysely).compile();
+            if (isSqlMutation(compiledQuery.sql))
+                throw new Error("SQL mutation (INSERT, UPDATE, DELETE, etc.) isn't allowed in the Evolu `createQuery` function. Kysely suggests it because there is no read-only Kysely yet, and removing such an API is not possible. For mutations, use Evolu Mutation API.");
+            return serializeQuery({
+                sql: compiledQuery.sql,
+                parameters: compiledQuery.parameters,
+                ...(options && { options }),
+            });
+        },
+        loadQuery: (query) => {
+            const { promise, isNew } = loadingPromises.get(query);
+            if (isNew) {
+                loadQueryMicrotaskQueue.push(query);
+                if (loadQueryMicrotaskQueue.length === 1) {
+                    queueMicrotask(() => {
+                        // Dedupe
+                        const queries = [...new Set(loadQueryMicrotaskQueue)];
+                        loadQueryMicrotaskQueue.length = 0;
+                        assertNonEmptyArray(queries);
+                        dbWorker.postMessage({
+                            type: "query",
+                            tabId: getTabId(),
+                            queries,
+                        });
+                    });
+                }
+            }
+            return promise;
+        },
+        loadQueries: (queries) => queries.map(evolu.loadQuery),
+        subscribeQuery: (query) => (listener) => {
+            // Call the listener only if the result has been changed.
+            let previousResult = null;
+            const unsubscribe = subscribedQueries.subscribe(query)(() => {
+                const result = evolu.getQueryRows(query);
+                if (previousResult === result)
+                    return;
+                previousResult = result;
+                listener();
+            });
+            return () => {
+                previousResult = null;
+                unsubscribe();
+            };
+        },
+        getQueryRows: (query) => (rowsStore.get().get(query) ?? emptyRows),
+        subscribeAppOwner: ownerStore.subscribe,
+        getAppOwner: ownerStore.get,
+        subscribeSyncState: syncStore.subscribe,
+        getSyncState: syncStore.get,
+        insert: createMutation("insert"),
+        update: createMutation("update"),
+        upsert: createMutation("upsert"),
+        resetAppOwner: (options) => {
+            // Eslint bug, Promise<void> is correct by docs.
+            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+            const { promise, resolve } = Promise.withResolvers();
+            const onCompleteId = callbacks.register(() => {
+                resolve();
+            });
+            dbWorker.postMessage({
+                type: "reset",
+                onCompleteId,
+                reload: options?.reload ?? true,
+            });
+            return promise;
+        },
+        restoreAppOwner: (mnemonic, options) => {
+            // Eslint bug, Promise<void> is correct by docs.
+            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+            const { promise, resolve } = Promise.withResolvers();
+            const onCompleteId = callbacks.register(() => {
+                resolve();
+            });
+            dbWorker.postMessage({
+                type: "reset",
+                onCompleteId,
+                reload: options?.reload ?? true,
+                restore: { mnemonic, dbSchema },
+            });
+            return promise;
+        },
+        reloadApp: () => {
+            appState.reset();
+        },
+        ensureSchema: (schema) => {
+            mutationTypesCache.clear();
+            const validSchema = assertValidEvoluSchema(schema);
+            dbWorker.postMessage({
+                type: "ensureDbSchema",
+                dbSchema: validEvoluSchemaToDbSchema(validSchema),
+            });
+        },
+        exportDatabase: () => {
+            const { promise, resolve } = Promise.withResolvers();
+            const onCompleteId = callbacks.register((arg) => {
+                if (arg instanceof Uint8Array)
+                    resolve(arg);
+            });
+            dbWorker.postMessage({ type: "export", onCompleteId });
+            return promise;
+        },
+    };
+    return evolu;
+};
+export const createNamespaceName = (config) => (name) => `evolu:${config.name}:${name}`;
+const createLoadingPromises = (subscribedQueries) => {
+    const loadingPromiseMap = new Map();
+    const loadingPromises = {
+        get: (query) => {
+            let loadingPromise = loadingPromiseMap.get(query);
+            const isNew = !loadingPromise;
+            if (!loadingPromise) {
+                const { promise, resolve } = Promise.withResolvers();
+                loadingPromise = { resolve, promise, releaseOnResolve: false };
+                loadingPromiseMap.set(query, loadingPromise);
+            }
+            return {
+                promise: loadingPromise.promise,
+                isNew,
+            };
+        },
+        resolve: (query, rows) => {
+            const loadingPromise = loadingPromiseMap.get(query);
+            if (!loadingPromise)
+                return;
+            if (loadingPromise.promise.status !== "fulfilled") {
+                loadingPromise.resolve(rows);
+            }
+            else {
+                // A promise can't be fulfilled 2x, so we need a new one.
+                loadingPromise.promise = Promise.resolve(rows);
+            }
+            /**
+             * "For example, a data framework can set the status and value fields on a
+             * promise preemptively, before passing to React, so that React can unwrap
+             * it without waiting a microtask."
+             * https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
+             */
+            void Object.assign(loadingPromise.promise, {
+                status: "fulfilled",
+                value: rows,
+            });
+            if (loadingPromise.releaseOnResolve) {
+                loadingPromiseMap.delete(query);
+            }
+        },
+        /**
+         * We can't delete loading promises in `resolveLoadingPromises` because they
+         * must be cached, so repeated calls to `loadQuery` will always return the
+         * same promise until the data changes, and we also can't cache them forever
+         * because only subscribed queries are automatically updated (reactivity is
+         * expensive) hence this function must be called manually on any mutation.
+         */
+        releaseUnsubscribed: () => {
+            [...loadingPromiseMap.entries()]
+                .filter(([query]) => !subscribedQueries.has(query))
+                .forEach(([query, loadingPromise]) => {
+                if (loadingPromise.promise.status === "fulfilled") {
+                    loadingPromiseMap.delete(query);
+                }
+                else {
+                    loadingPromise.releaseOnResolve = true;
+                }
+            });
+        },
+    };
+    return loadingPromises;
+};

package/dist/src/Evolu/Internal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 🛠️
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { Evolu } from "@evolu/common/evolu";
+ * ```
+ *
+ * @module
+ */
+export * from "./Config.js";
+export * from "./Db.js";
+export * from "./Diff.js";
+export * from "./Evolu.js";
+export * from "./Kysely.js";
+export * from "./Owner.js";
+export * from "./Platform.js";
+export * from "./Protocol.js";
+export * from "./Query.js";
+export * from "./Relay.js";
+export * from "./Schema.js";
+export * from "./Storage.js";
+export * from "./Sync.js";
+export * from "./Timestamp.js";
+//# sourceMappingURL=Internal.d.ts.map

package/dist/src/Evolu/Internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Internal.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

package/dist/src/Evolu/Internal.js

@@ -0,0 +1,25 @@
+/**
+ * 🛠️
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { Evolu } from "@evolu/common/evolu";
+ * ```
+ *
+ * @module
+ */
+export * from "./Config.js";
+export * from "./Db.js";
+export * from "./Diff.js";
+export * from "./Evolu.js";
+export * from "./Kysely.js";
+export * from "./Owner.js";
+export * from "./Platform.js";
+export * from "./Protocol.js";
+export * from "./Query.js";
+export * from "./Relay.js";
+export * from "./Schema.js";
+export * from "./Storage.js";
+export * from "./Sync.js";
+export * from "./Timestamp.js";

package/dist/src/Evolu/Kysely.d.ts

@@ -0,0 +1,6 @@
+import { CreateIndexBuilder, Kysely } from "kysely";
+import { DbIndex } from "./Db.js";
+export declare const kysely: Kysely<unknown>;
+export type DbIndexesBuilder = (create: (indexName: string) => CreateIndexBuilder) => ReadonlyArray<CreateIndexBuilder<any>>;
+export declare const createIndexes: (indexes?: DbIndexesBuilder) => ReadonlyArray<DbIndex>;
+//# sourceMappingURL=Kysely.d.ts.map

package/dist/src/Evolu/Kysely.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Kysely.d.ts","sourceRoot":"","sources":["../../../src/Evolu/Kysely.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAElB,MAAM,EAGP,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGlC,eAAO,MAAM,MAAM,iBASjB,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,kBAAkB,KAC9C,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;AAI5C,eAAO,MAAM,aAAa,GACxB,UAAU,gBAAgB,KACzB,aAAa,CAAC,OAAO,CAQvB,CAAC"}

package/dist/src/Evolu/Kysely.js

@@ -0,0 +1,21 @@
+import { DummyDriver, Kysely, SqliteAdapter, SqliteQueryCompiler, } from "kysely";
+// https://kysely.dev/docs/recipes/splitting-query-building-and-execution
+export const kysely = new Kysely({
+    dialect: {
+        createAdapter: () => new SqliteAdapter(),
+        createDriver: () => new DummyDriver(),
+        createIntrospector() {
+            throw new Error("Not implemeneted");
+        },
+        createQueryCompiler: () => new SqliteQueryCompiler(),
+    },
+});
+const createIndex = kysely.schema.createIndex.bind(kysely.schema);
+export const createIndexes = (indexes) => {
+    if (!indexes)
+        return [];
+    return indexes(createIndex).map((index) => ({
+        name: index.toOperationNode().name.name,
+        sql: index.compile().sql,
+    }));
+};

package/dist/src/Evolu/Owner.d.ts

@@ -0,0 +1,155 @@
+import { CreateMnemonicDep, CreateRandomBytesDep, EncryptionKey, MnemonicSeed } from "../Crypto.js";
+import { NanoIdLibDep } from "../NanoId.js";
+import { TimeDep } from "../Time.js";
+import { DateIsoString, Mnemonic, NonNegativeInt } from "../Type.js";
+import { TimestampString } from "./Timestamp.js";
+/**
+ * `Owner` is an entity in Evolu that owns data, meaning it is locally stored on
+ * a device under the user’s control. Data can be personal private, peer-to-peer
+ * shared, or aggregated from multiple owners.
+ *
+ * An owner has a {@link Mnemonic} from which {@link OwnerId} and
+ * {@link EncryptionKey} are deterministically derived using SLIP-21, and an
+ * optional {@link WriteKey} that, when present, enables writing to the Evolu
+ * Relay or peers. The {@link WriteKey} can be rotated.
+ *
+ * Variants include {@link AppOwner}, {@link ShardOwner}, {@link SharedOwner}, and
+ * {@link SharedReadonlyOwner}, each with specific roles and properties detailed
+ * in their respective definitions.
+ *
+ * Public-key cryptography isn’t included here as it belongs to data and varies
+ * by use case. An Evolu app without collaboration doesn’t need it, while a
+ * Nostr-like app can leverage Nostr NIPs, or a super-safe app can use
+ * post-quantum cryptography.
+ */
+export interface Owner {
+    readonly mnemonic: Mnemonic;
+    readonly createdAt: DateIsoString;
+    readonly id: OwnerId;
+    readonly encryptionKey: EncryptionKey;
+    readonly writeKey: WriteKey;
+}
+export interface OwnerWithWriteAccess {
+    readonly id: OwnerId;
+    readonly encryptionKey: EncryptionKey;
+    readonly writeKey: WriteKey;
+}
+/**
+ * The unique identifier of {@link Owner} derived from the {@link Mnemonic}.
+ *
+ * This branded {@link Id} type, generated by {@link createSlip21Id}, is a
+ * 21-character {@link Base64Url} string (126 bits of entropy), providing a
+ * compact, shareable, and secure identifier for UI use, tied to the owner's
+ * mnemonic and derivation path.
+ */
+export declare const OwnerId: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"String", string, string, import("../Type.js").StringError, string, import("../Type.js").StringError>, "Id", import("../Type.js").RegexError<"Id">, import("../Type.js").StringError>, "OwnerId", import("../Type.js").BrandWithoutRefineError<"OwnerId", import("../Type.js").StringError | import("../Type.js").RegexError<"Id">>, never>;
+export type OwnerId = typeof OwnerId.Type;
+export declare const writeKeyLength: NonNegativeInt;
+/**
+ * A secure token proving the initiator can write changes. Derived from a
+ * mnemonic or randomly generated. It's rotatable.
+ */
+export declare const WriteKey: import("../Type.js").BrandType<import("../Type.js").BrandType<import("../Type.js").Type<"Uint8Array", Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError, Uint8Array<ArrayBufferLike>, import("../Type.js").Uint8ArrayError>, `Length${number & import("../Types.js").Brand<"Int"> & import("../Types.js").Brand<"NonNegative">}`, import("../Type.js").LengthError<number & import("../Types.js").Brand<"Int"> & import("../Types.js").Brand<"NonNegative">>, import("../Type.js").Uint8ArrayError>, "WriteKey", import("../Type.js").BrandWithoutRefineError<"WriteKey", import("../Type.js").Uint8ArrayError | import("../Type.js").LengthError<number & import("../Types.js").Brand<"Int"> & import("../Types.js").Brand<"NonNegative">>>, never>;
+export type WriteKey = typeof WriteKey.Type;
+/**
+ * The root owner of an Evolu app, created from a mnemonic safely generated on a
+ * device when the app is initialized or restored on another device using an
+ * existing mnemonic. It manages the app's core data, including the storage of
+ * other owners' mnemonics in an encrypted app table. Its `writeKey` is
+ * deterministic and rotatable. Never share the AppOwner mnemonic with anyone.
+ */
+export interface AppOwner extends Owner {
+    readonly type: "AppOwner";
+}
+/**
+ * Used to shard data within an app for partial or deferred sync. Created in the
+ * Evolu `initialData` function or dynamically as needed. Its mnemonic is stored
+ * in an app table (encrypted by `AppOwner`) and synced between devices. Its
+ * `writeKey` is deterministic and rotatable, enabling selective syncing of data
+ * subsets. Not intended for sharing outside the app.
+ *
+ * This type omits `id`, `encryptionKey`, and `createdAt` as they are derived by
+ * Evolu from the `mnemonic`, reducing storage overhead.
+ */
+export interface ShardOwner {
+    readonly type: "ShardOwner";
+    readonly mnemonic: Mnemonic;
+    readonly writeKey: WriteKey;
+}
+/**
+ * Used to share data among one or more users, enabling collaboration or
+ * controlled access. Its `writeKey` is random (not derived from the mnemonic,
+ * stored alongside it in the app table) and rotatable, ensuring it cannot be
+ * regenerated by others if shared. Share the `mnemonic` alone for read-only
+ * access (as `SharedReadonlyOwner`) or share SharedOwner itself for write
+ * access.
+ *
+ * This type omits `id`, `encryptionKey`, and `createdAt` as they are derived by
+ * Evolu from the `mnemonic`, reducing storage overhead.
+ */
+export interface SharedOwner {
+    readonly type: "SharedOwner";
+    readonly mnemonic: Mnemonic;
+    readonly writeKey: WriteKey;
+}
+/**
+ * Used for sharing data that can only be read, such as with followers or peers
+ * in a read-only sync scenario. It lacks a `writeKey`, containing only the
+ * `mnemonic` from which `id` and `encryptionKey` are derived by Evolu.
+ * Typically derived from a `SharedOwner` by sharing its `mnemonic` without the
+ * `writeKey`.
+ */
+export interface SharedReadonlyOwner {
+    readonly type: "SharedReadonlyOwner";
+    readonly mnemonic: Mnemonic;
+}
+/**
+ * Creates an {@link AppOwner}, optionally from an existing mnemonic to restore
+ * it on another device; otherwise, generates a new mnemonic.
+ */
+export declare const createAppOwner: (deps: TimeDep & CreateRandomBytesDep & CreateMnemonicDep) => (mnemonic?: string & import("../Types.js").Brand<"Trimmed"> & import("../Types.js").Brand<"MinLength1"> & import("../Types.js").Brand<"Mnemonic">) => AppOwner;
+/**
+ * Creates a {@link ShardOwner} for sharding app data with a freshly generated
+ * mnemonic. Unlike {@link createAppOwner}, it doesn’t accept an existing
+ * mnemonic because ShardOwner mnemonics are always generated and restored
+ * automatically via database sync.
+ */
+export declare const createShardOwner: (deps: TimeDep & CreateRandomBytesDep & CreateMnemonicDep) => ShardOwner;
+/**
+ * Creates a fresh {@link SharedOwner} for sharing data with write access. Takes
+ * no arguments as both `mnemonic` and rotatable `writeKey` are newly generated;
+ * when shared, recipients use the provided `mnemonic` and `writeKey` directly
+ * as a {@link SharedOwner} without needing to recreate it.
+ */
+export declare const createSharedOwner: (deps: CreateRandomBytesDep & CreateMnemonicDep) => SharedOwner;
+/**
+ * Creates a {@link SharedReadonlyOwner} from a {@link SharedOwner} for read-only
+ * data sharing. Extracts the `mnemonic` from the provided {@link SharedOwner},
+ * omitting its `writeKey` to ensure read-only access.
+ */
+export declare const createSharedReadonlyOwner: (sharedOwner: SharedOwner) => SharedReadonlyOwner;
+/** Creates an {@link Owner} with optional `mnemonic` and `writeKey`. */
+export declare const createOwner: (deps: TimeDep & CreateRandomBytesDep & CreateMnemonicDep) => (mnemonic?: string & import("../Types.js").Brand<"Trimmed"> & import("../Types.js").Brand<"MinLength1"> & import("../Types.js").Brand<"Mnemonic">, writeKey?: WriteKey) => Owner;
+export declare const createWriteKey: (deps: CreateRandomBytesDep) => (seed?: MnemonicSeed) => WriteKey;
+/**
+ * An `OwnerRow` represents a row in the `evolu_owner` table, based on an
+ * {@link Owner} with an added `timestamp` ({@link TimestampString}) for CRDT
+ * sync. It supports all {@link Owner} variants with an optional `writeKey`; use
+ * {@link createOwnerRow} to align it with a specific {@link Owner}.
+ */
+export type OwnerRow = Omit<Owner, "writeKey"> & {
+    readonly writeKey: WriteKey | null;
+    readonly timestamp: TimestampString;
+};
+/**
+ * Creates an {@link OwnerRow} from any {@link Owner} variant for the
+ * `evolu_owner` table, adding a `timestamp` ({@link TimestampString}) for CRDT
+ * sync.
+ */
+export declare const createOwnerRow: (deps: TimeDep & CreateRandomBytesDep & CreateMnemonicDep & NanoIdLibDep) => (owner: AppOwner | ShardOwner | SharedOwner | SharedReadonlyOwner) => OwnerRow;
+/**
+ * Rotates the {@link WriteKey} for an {@link AppOwner}, {@link ShardOwner}, or
+ * {@link SharedOwner}, returning a new instance with the updated key.
+ */
+export declare const rotateWriteKey: <T extends AppOwner | ShardOwner | SharedOwner>(owner: T, newWriteKey: WriteKey) => T;
+//# sourceMappingURL=Owner.d.ts.map