@seedprotocol/sdk 0.7.5 → 0.7.6

package/dist/dist/errors-3tc6XkCB.d.ts

@@ -0,0 +1,487 @@
+/**
+ * Error thrown when a conflict is detected between actor context and database
+ */
+declare class ConflictError extends Error {
+    constructor(message: any, conflict: any);
+    conflict: any;
+}
+/**
+ * Thrown by Item.create when values don't fit the model: unknown keys, wrong types, or values
+ * that break the property's validation rules. Nothing is left written: most values are checked
+ * before anything is written, and File/Image/Html/ItemStorage values, checked as they're saved,
+ * have their draft removed.
+ */
+declare class ItemCreateValidationError extends Error {
+    constructor(modelName: any, problems: any);
+    modelName: any;
+    problems: any;
+}
+declare class Model {
+    static trackPendingWrite(modelFileId: any, schemaId: any): void;
+    static getPendingModelIds(schemaId: any): any[];
+    /**
+     * Resolves once the model is idle and any properties passed to Model.create exist.
+     * Rejects if it errors, times out, or its properties can't be created.
+     */
+    static waitUntilReady(instance: any, timeout: any): Promise<any>;
+    /**
+     * Gives an idle, valid model the row someone else wrote for its id, the way its own write would
+     * (writeSuccess with the row's id, which goes on to create its properties from their rows).
+     * Returns false when there is no such row, so the model writes it.
+     */
+    static adoptPersistedRow(instance: any): Promise<boolean>;
+    /**
+     * True when a name-cached instance belongs to a different model than the requested modelFileId.
+     * A schema re-imported under the same name can give its models new ids while the previous
+     * instances are still cached by name; Model.create must not hand those back for the new id.
+     */
+    static isOtherModelId(cachedId: any, requestedId: any): boolean;
+    /**
+     * Find a unique model name by checking for duplicates (case-insensitive) in the cache
+     * If duplicates are found, appends an incrementing number to make it unique
+     *
+     * @param modelName - The desired model name
+     * @param schemaName - The schema name
+     * @param skipAllChecks - If true, skip all duplicate checks and return original name (used when creating schema models to preserve original names)
+     * @returns A unique model name
+     */
+    static findUniqueModelName(modelName: any, schemaName: any, skipAllChecks?: boolean): any;
+    static create(modelName: any, schemaNameOrSchema: any, options: any): any;
+    /**
+     * Get Model instance by modelFileId (O(1) lookup)
+     */
+    static getById(modelFileId: any): any;
+    /**
+     * Get Model instance by name (O(1) lookup via name→ID mapping)
+     *
+     * @param modelName - The name of the model
+     * @param schemaName - The schema name (optional, will query DB if not provided)
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static getByName(modelName: any, schemaName: any): any;
+    /** The one cached Model whose name matches, or AmbiguousModelError if models from several schemas do. */
+    static _getUniqueCachedModel(label: any, matches: any): any;
+    /**
+     * Resolve a cached Model from the most specific scope available: modelFileId (Model.id), then
+     * schemaName + modelName, then modelName alone.
+     */
+    static resolve(modelName: any, scope?: {}): any;
+    /**
+     * Find Model by modelType (an EAS model name, as seeds.type stores it). Matched as ADR 0008
+     * matches EAS names: `new_model` finds "New model", and `htmlpage` (an older SDK's name) finds
+     * "HTMLPage", unless HTMLPage's nameMatch (ADR 0009) is `exact`. Only the tightest matching tier
+     * counts; matches in several schemas are ambiguous.
+     */
+    static findByModelType(modelType: any): any;
+    /**
+     * Get all Model instances for a schema from cache only (synchronous).
+     * Includes models created at runtime via Model.create() that may not yet be in schema context.
+     */
+    static getCachedInstancesForSchema(schemaName: any): any[];
+    /**
+     * Async Model.resolve(): exact cache hit by modelFileId or schemaName+modelName, else the DB row for
+     * that scope (instantiating the Model), and only then the name-only fallback.
+     */
+    static resolveAsync(modelName: any, scope?: {}): Promise<any>;
+    /**
+     * Get Model instance by name, querying database if not in cache
+     * This is an async version that can query the database when schemaName is not provided
+     *
+     * @param modelName - The name of the model
+     * @param schemaName - Optional schema name (will query DB if not provided)
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static getByNameAsync(modelName: any, schemaName: any, options: any): Promise<any>;
+    /**
+     * Create or get Model instance by modelFileId
+     * Checks cache first, then database if not found
+     *
+     * @param modelFileId - The model file ID to look up
+     * @returns The Model instance if found, undefined otherwise
+     */
+    static createById(modelFileId: any, options: any): Promise<any>;
+    /**
+     * Find Model instance by modelFileId, modelName/schemaName, or both
+     * Waits for the model to be fully loaded (idle state) by default
+     * @param options - Find options including lookup parameters and wait configuration
+     * @returns Model instance if found, undefined otherwise
+     */
+    static find({ modelFileId, modelName, schemaName, waitForReady, readyTimeout, }: {
+        modelFileId: any;
+        modelName: any;
+        schemaName: any;
+        waitForReady?: boolean | undefined;
+        readyTimeout?: number | undefined;
+    }): Promise<any>;
+    /**
+     * Get all Model instances for a schema by schemaFileId or schemaName
+     * Queries database for all models with the given schemaId/schemaName and returns Model instances
+     *
+     * @param schemaIdentifier - The schema file ID or schema name to get models for
+     * @returns Array of Model instances for the schema
+     */
+    static createBySchemaId(schemaIdentifier: any): Promise<any[]>;
+    /**
+     * Get all Model instances, optionally filtered by schema.
+     * When DB is available, loads from DB via getModelsData; otherwise returns from cache.
+     * With waitForReady, waits for each model to be ready (idle, with any properties from Model.create
+     * created) and leaves out models that error or time out.
+     */
+    static all(schemaName: any, options: any): Promise<any[]>;
+    /**
+     * Update name index when model name changes
+     */
+    static updateNameIndex(oldName: any, newName: any, schemaName: any, modelFileId: any): void;
+    /**
+     * Force-evict every cached Model belonging to a schema, ignoring refCounts, and stop their services.
+     * Used by Schema.destroy(): once the DB rows are gone, cached instances would keep a dangling _dbId
+     * and be handed back by Model.create/Model.all after the schema is re-imported.
+     * @returns names of the evicted models (so callers can evict their ModelProperty instances)
+     */
+    static evictForSchema(schemaName: any): any[];
+    /**
+     * Refresh the property ids of every cached Model whose DB row is `dbId`. Called when a property
+     * write for that model finishes: until then `properties` includes it as a pending write, and in Node
+     * (no reactive liveQuery) nothing else adds it to `_liveQueryPropertyIds`.
+     */
+    static refreshPropertiesForDbId(dbId: any): Promise<void>;
+    constructor(modelName: any, schemaName: any, id: any, initialContext: any, idFromSchema: any);
+    _service: import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {
+        src: "loadOrCreateModel";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateModel";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createModelProperties";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeProcessMachine";
+        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }, import("xstate").MetaObject>>;
+    getService(): import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {
+        src: "loadOrCreateModel";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateModel";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createModelProperties";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeProcessMachine";
+        logic: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }, import("xstate").MetaObject>>;
+    _getSnapshot(): import("xstate").MachineSnapshot<{}, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+            [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+        }, {
+            src: "validateEntity";
+            logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        } | {
+            src: "writeToDatabase";
+            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+            id: string | undefined;
+        }, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+            id: "writeProcess";
+            states: {
+                readonly idle: {};
+                readonly validating: {};
+                readonly writing: {};
+                readonly success: {};
+                readonly error: {};
+            };
+        }, import("xstate").MetaObject>> | undefined;
+    }, {}, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>;
+    _getSnapshotContext(): {};
+    /**
+     * Check for conflicts between actor context and database
+     * @returns ConflictResult indicating if a conflict exists
+     */
+    _checkForConflicts(): Promise<{
+        hasConflict: boolean;
+    }>;
+    /**
+     * Saves model name changes to the database immediately (draft save)
+     * This is called when modelName is changed to persist the change immediately
+     * @param oldName - The old model name (if name changed)
+     * @param newName - The new model name
+     */
+    _saveDraftToDb(oldName: any, newName: any): Promise<void>;
+    get status(): {};
+    /** The error from the last draft save a rename started, or undefined once a later one succeeds. */
+    get lastSaveError(): any;
+    get validationErrors(): any;
+    get isValid(): boolean;
+    get isEdited(): any;
+    get id(): any;
+    get name(): any;
+    /**
+     * Returns ModelProperty instances for this model
+     * This is a computed property that reads from the service context
+     * Note: This is NOT reactive - use useModelProperties() hook for reactivity
+     */
+    get properties(): any[];
+    /**
+     * Validate the model
+     * @returns Validation result
+     */
+    validate(): Promise<any>;
+    /**
+     * Create a new item instance from this model
+     * Automatically injects the model name, so you don't need to pass it explicitly.
+     *
+     * @example
+     * const Post = Model.create('Post', schema)
+     * const post = await Post.create({ title: 'My Post', content: '...' })
+     *
+     * @param values - Item property values (modelName is automatically injected)
+     * @returns The created item instance
+     */
+    create(values: any): Promise<any>;
+    /**
+     * Reload model from database
+     * This refreshes the actor context with the latest data from the database
+     */
+    reload(): Promise<any>;
+    /**
+     * Unload the model instance and clean up resources
+     */
+    unload(): void;
+    /**
+     * Destroy the model instance completely: remove from caches, delete from database,
+     * update Schema context, stop service. Uses shared destroy helpers.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Set up liveQuery subscription to watch for property changes in the database
+     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
+     */
+    _setupLiveQuerySubscription(): void;
+    /**
+     * Refresh property IDs from database (useful in Node.js where liveQuery isn't available)
+     */
+    _refreshPropertiesFromDb(): Promise<void>;
+    /**
+     * Public method to refresh properties from database
+     */
+    refreshProperties(): Promise<void>;
+}
+declare namespace Model {
+    let instanceCacheById: Map<any, any>;
+    let instanceCacheByName: Map<any, any>;
+    let instanceCache: Map<any, any>;
+    let pendingWrites: Map<any, any>;
+    let savingModels: Set<any>;
+    let cachedClientInitialized: any;
+    let clientCheckTime: number;
+    let CLIENT_CHECK_CACHE_MS: number;
+}
+declare const TModelSchema: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    _dbId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    dataType: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"Text">, import("@sinclair/typebox").TLiteral<"Number">, import("@sinclair/typebox").TLiteral<"List">, import("@sinclair/typebox").TLiteral<"Relation">, import("@sinclair/typebox").TLiteral<"Image">, import("@sinclair/typebox").TLiteral<"Json">, import("@sinclair/typebox").TLiteral<"File">, import("@sinclair/typebox").TLiteral<"Boolean">, import("@sinclair/typebox").TLiteral<"Date">, import("@sinclair/typebox").TLiteral<"Html">]>;
+    ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    modelId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString]>>;
+    modelName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    refModelId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    refModelName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    refValueType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"Text">, import("@sinclair/typebox").TLiteral<"Number">, import("@sinclair/typebox").TLiteral<"List">, import("@sinclair/typebox").TLiteral<"Relation">, import("@sinclair/typebox").TLiteral<"Image">, import("@sinclair/typebox").TLiteral<"Json">, import("@sinclair/typebox").TLiteral<"File">, import("@sinclair/typebox").TLiteral<"Boolean">, import("@sinclair/typebox").TLiteral<"Date">, import("@sinclair/typebox").TLiteral<"Html">]>>;
+    storageType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"ItemStorage">, import("@sinclair/typebox").TLiteral<"PropertyStorage">]>>;
+    localStorageDir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    filenameSuffix: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    validation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        pattern: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        minLength: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxLength: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        enum: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TAny>>;
+        custom: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+    required: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    htmlEmbeddedDataUriPolicy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"materialize">, import("@sinclair/typebox").TLiteral<"preserve">]>>;
+}>>;
+/** Thrown by Item.create when no model with that name exists (in the given schema, if any). */
+declare class UnknownModelError extends Error {
+    constructor(modelName: any, schemaName: any);
+    modelName: any;
+    schemaName: any;
+}
+declare const TModelValues: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>;
+/**
+ * True when any schema was evicted after `since` or is being destroyed (cheap check before looking up
+ * which schemas apply).
+ */
+declare function anyEvictionSince(since: any): boolean;
+declare function currentEvictionEpoch(): number;
+/**
+ * Set up liveQuery subscription for an entity
+ * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
+ *
+ * @param instance - Entity instance
+ * @param config - LiveQuery configuration
+ */
+declare function setupEntityLiveQuery(instance: any, config: any): void;
+declare var writeToDatabase$1: Readonly<{
+    __proto__: null;
+    waitForInFlightWrites: (timeoutMs?: number) => Promise<void>;
+    writeToDatabase: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+}>;
+declare function finishSchemaDestroy(schemaName: any): void;
+declare function getDraftSaveError(service: any): any;
+declare var Model$1: Readonly<{
+    __proto__: null;
+    Model: typeof Model;
+}>;
+/**
+ * Common getters and utilities for entity classes
+ * These work with any entity that has a getService() method returning an XState actor
+ */
+/**
+ * Get the current state value from an entity's service
+ */
+/**
+ * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
+ * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
+ * events and XState warns about every one of them.
+ */
+declare function isActorStopped(actor: any): boolean;
+declare var errors: Readonly<{
+    __proto__: null;
+    ItemCreateValidationError: typeof ItemCreateValidationError;
+    UnknownModelError: typeof UnknownModelError;
+}>;
+/**
+ * Called by Schema.destroy before it evicts the schema's models; `finishSchemaDestroy` once its rows
+ * are gone. The schema's actor stays live until then, and work it starts meanwhile (its live query
+ * reading a model row the drained write just landed) captures an epoch after the eviction, so the
+ * epoch alone can't tell it to stay away.
+ */
+declare function recordSchemaDestroy(schemaName: any): void;
+/**
+ * True when the schema is being destroyed, or its instances were evicted after `since` (an epoch
+ * from currentEvictionEpoch).
+ */
+declare function schemaEvictedSince(schemaName: any, since: any): boolean;
+/** Run a background draft save, recording its failure (or clearing an earlier one on success). */
+declare function trackDraftSave(service: any, save: any, label: any): void;
+declare const writeProcessMachine: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject> | import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+}, {
+    src: "validateEntity";
+    logic: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeToDatabase";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, never, never, "error" | "idle" | "validating" | "writing" | "success", string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "writeProcess";
+    states: {
+        readonly idle: {};
+        readonly validating: {};
+        readonly writing: {};
+        readonly success: {};
+        readonly error: {};
+    };
+}, import("xstate").MetaObject>;
+export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, setupEntityLiveQuery as d, writeToDatabase$1 as e, finishSchemaDestroy as f, getDraftSaveError as g, Model$1 as h, isActorStopped as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
+//# sourceMappingURL=errors-3tc6XkCB.d.ts.map

package/dist/dist/errors-3tc6XkCB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-3tc6XkCB.d.ts","sourceRoot":"","sources":["../errors-3tc6XkCB.js"],"names":[],"mappings":"AA2uDA;;GAEG;AACH;IACI,yCAKC;IAFG,cAAwB;CAG/B;AA0uED;;;;;GAKG;AACH;IACI,2CAMC;IAHG,eAA0B;IAC1B,cAAwB;CAG/B;AAl/DD;IACI,gEAOC;IACD,gDAIC;IAsCD;;;OAGG;IACH,iEAuBC;IACD;;;;OAIG;IACH,0DAkBC;IACD;;;;OAIG;IACH,gEAEC;IACD;;;;;;;;OAQG;IACH,0FA6DC;IACD,0EAonBC;IACD;;OAEG;IACH,sCAWC;IACD;;;;;;OAMG;IACH,uDAaC;IACD,yGAAyG;IACzG,4DAcC;IACD;;;OAGG;IACH,gDAcC;IACD;;;;;OAKG;IACH,4CAQC;IACD;;;OAGG;IACH,2DAyBC;IACD;;;OAGG;IACH,8DA6CC;IACD;;;;;;;OAOG;IACH,mFA4DC;IACD;;;;;;OAMG;IACH,gEA4DC;IACD;;;;;OAKG;IACH;;;;;;qBAoBC;IACD;;;;;;OAMG;IACH,+DA4DC;IACD;;;;;OAKG;IACH,0DA8FC;IACD;;OAEG;IACH,4FAeC;IAmTD;;;;;OAKG;IACH,8CAuCC;IAmSD;;;;OAIG;IACH,0DAkBC;IA37DD,8FAmCC;IAzBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAsxCN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD;;;OAGG;IACH;;OA+BC;IACD;;;;;OAKG;IACH,0DAgGC;IACD,iBAEC;IACD,mGAAmG;IACnG,yBAEC;IACD,4BAEC;IACD,uBAGC;IACD,oBAcC;IACD,cAEC;IACD,gBAEC;IACD;;;;OAIG;IACH,wBA8BC;IACD;;;OAGG;IACH,yBA8BC;IACD;;;;;;;;;;OAUG;IACH,kCAWC;IACD;;;OAGG;IACH,uBAwBC;IA+CD;;OAEG;IACH,eA4BC;IACD;;;OAGG;IACH,yBAsEC;IACD;;;OAGG;IACH,oCAsGC;IACD;;OAEG;IACH,0CAkEC;IACD;;OAEG;IACH,mCAEC;CAyBJ;;;;;;;;;;;AAuBD;;;;;;;;;;;;;;;;;;;;;;;IAA2D;AAiB3D,+FAA+F;AAC/F;IACI,6CAMC;IAHG,eAA0B;IAC1B,gBAA4B;CAGnC;AA3BD,uIAA4D;AAxnG5D;;;GAGG;AACH,uDAEC;AA3ED,gDAEC;AAs9BD;;;;;;GAMG;AACH,wEAyJC;AAzxBD;;;;GAIG;AAjVH,4DAQC;AAkpCD,sDAEC;AAygED;;;GAGG;AA/8HH;;;GAGG;AACH;;GAEG;AACH;;;;GAIG;AACH,qDAEC;AAi+HD;;;;GAIG;AAttGH;;;;;GAKG;AACH,4DAGC;AAUD;;;GAGG;AACH,0EAQC;AAwoCD,kGAAkG;AAClG,2EAQC;AAl1BD;;;;;;;;;;;;;;;;;;;gCA2NG"}

package/dist/dist/errors-Do7v6RKu.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Thrown by client init in the browser when SQLite can't store the database in OPFS. SQLite's OPFS
+ * storage needs `SharedArrayBuffer`, which browsers only expose on cross-origin isolated pages
+ * (COOP `same-origin` and COEP `require-corp` or `credentialless` response headers). Without it,
+ * SQLocal falls back to an in-memory database and every reload would lose the app's data, so init
+ * fails instead. Hosts can check `code === 'DB_NOT_PERSISTENT'`.
+ */
+declare class DatabaseNotPersistentError extends Error {
+    constructor(detail: any);
+    code: string;
+}
+/**
+ * Thrown by client init when the browser file system can't be mounted because OPFS entries are
+ * held by another context — usually another tab of the same app, or a worker from a page that
+ * was just reloaded. Hosts can check `code === 'OPFS_LOCKED'` and offer "close other tabs / retry".
+ */
+declare class FileSystemLockedError extends Error {
+    constructor(cause: any);
+    code: string;
+}
+export { DatabaseNotPersistentError as D, FileSystemLockedError as F };
+//# sourceMappingURL=errors-Do7v6RKu.d.ts.map

package/dist/dist/errors-Do7v6RKu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-Do7v6RKu.d.ts","sourceRoot":"","sources":["../errors-Do7v6RKu.js"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH;IACI,yBAOC;IAFG,aAA+B;CAGtC;AA9BD;;;;GAIG;AACH;IACI,wBAMC;IAFG,aAAyB;CAGhC"}

package/dist/dist/getItem-DM3a-7XE.d.ts

@@ -0,0 +1,6 @@
+export function getItem({ modelName, seedLocalId, seedUid }: {
+    modelName: any;
+    seedLocalId: any;
+    seedUid: any;
+}): Promise<any>;
+//# sourceMappingURL=getItem-DM3a-7XE.d.ts.map

package/dist/dist/getItem-DM3a-7XE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getItem-DM3a-7XE.d.ts","sourceRoot":"","sources":["../getItem-DM3a-7XE.js"],"names":[],"mappings":"AAqBA;;;;iBAoBC"}

package/dist/dist/getPublishPayload-CJF0k5d8.d.ts

@@ -0,0 +1,47 @@
+/** Error thrown when publish validation fails. Includes all validation errors for user to fix. */
+declare class PublishValidationFailedError extends Error {
+    constructor(message: any, validationErrors: any);
+    validationErrors: any;
+}
+/** Validation error code for a relation, list member or image/file ref to an unpublished seed. */
+declare const RELATED_ITEM_UNPUBLISHED_CODE: "related_item_unpublished";
+/**
+ * Thrown before anything is uploaded or attested when the item references items whose seed was
+ * unpublished: the parent would attest a revoked seed uid. Republish those items (which gives
+ * them a new seed uid) or remove the references, then publish again.
+ * See docs/ATTESTATION_REVOCATION.md ("Republishing").
+ *
+ * A PublishValidationFailedError, so validateItemForPublish and the publish package's checking
+ * step report it as validation errors (code `related_item_unpublished`, one per reference).
+ */
+declare class RelatedItemUnpublishedError extends PublishValidationFailedError {
+    constructor(unpublishedRelatedItems: any, otherValidationErrors?: any[]);
+    unpublishedRelatedItems: any;
+}
+declare var getPublishPayload$1: Readonly<{
+    __proto__: null;
+    PublishValidationFailedError: typeof PublishValidationFailedError;
+    getPublishPayload: (item: any, uploadedTransactions: any, options: any) => Promise<any>;
+    resolvePublishPayloadValues: (multiPayload: any, resolvedUids: any) => Promise<any>;
+    validateItemForPublish: (item: any, uploadedTransactions: any[] | undefined, options: any) => Promise<{
+        isValid: boolean;
+        errors: any;
+    }>;
+}>;
+/**
+ * Resolves relation/image property values (seedLocalId) to attestation uids after dependent seeds are published.
+ * Call after each payload is published, passing the returned attestation uid for that seed's localId.
+ * Returns an updated multiPayload with re-encoded attestations where resolution was applied.
+ */
+declare function resolvePublishPayloadValues(multiPayload: any, resolvedUids: any): Promise<any>;
+/**
+ * Validates an item for publishing without performing Arweave or EAS work.
+ * Use in the checking step to fail fast before creating transactions.
+ * Pass empty array for uploadedTransactions when validating before Arweave upload.
+ */
+declare function validateItemForPublish(item: any, uploadedTransactions: any[] | undefined, options: any): Promise<{
+    isValid: boolean;
+    errors: any;
+}>;
+export { PublishValidationFailedError as P, RELATED_ITEM_UNPUBLISHED_CODE as R, RelatedItemUnpublishedError as a, getPublishPayload$1 as g, resolvePublishPayloadValues as r, validateItemForPublish as v };
+//# sourceMappingURL=getPublishPayload-CJF0k5d8.d.ts.map

package/dist/dist/getPublishPayload-CJF0k5d8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPublishPayload-CJF0k5d8.d.ts","sourceRoot":"","sources":["../getPublishPayload-CJF0k5d8.js"],"names":[],"mappings":"AA2DA,kGAAkG;AAClG;IACI,iDAIC;IAFG,sBAAwC;CAG/C;AACD,kGAAkG;AAClG,6CAAsC,0BAA0B,CAAC;AAEjE;;;;;;;;GAQG;AACH;IACI,yEAgBC;IADG,6BAAsD;CAE7D;AA6/CD;;;;;;;;;GAMG;AAnHH;;;;GAIG;AACH,iGAsGC;AAjRD;;;;GAIG;AACH;;;GAWC"}