@seedprotocol/sdk 0.7.9-next.1177.ga3e08ed → 0.7.9-next.1306.g4ff6582

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

@@ -1,515 +0,0 @@
-/**
- * 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). Takes a hold on the instance; release it with
-     * `unload()`.
-     */
-    static getById(modelFileId: any): any;
-    /**
-     * @internal For a Schema loading its models: true when this load should take the schema's hold
-     * on the model (pass no `hold` option), false when the schema already holds it (pass
-     * `hold: false`). After a true, call `dropSchemaHold` if the load returns no model.
-     */
-    static takeSchemaHold(modelFileId: any): boolean;
-    /** @internal The load `takeSchemaHold` approved found no model: there is no hold to release. */
-    static dropSchemaHold(modelFileId: any): void;
-    /** @internal A Schema's last unload: releases its hold on each of its models. */
-    static releaseSchemaHolds(schemaName: any): void;
-    /**
-     * The cached Model with this modelFileId, without taking a hold. For SDK code that reads the
-     * model and doesn't hand it to a caller; callers that keep it use `getById`, `find` or `create`.
-     */
-    static peek(modelFileId: any): any;
-    /**
-     * Get Model instance by name (O(1) lookup via name→ID mapping). Takes a hold on the instance;
-     * release it with `unload()`.
-     *
-     * @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;
-    /**
-     * `getByName` without taking a hold. Without `schemaName` it searches every cached schema and
-     * throws AmbiguousModelError when models from several schemas share the name; callers that know
-     * the schema or model id should use Model.resolve() instead.
-     */
-    static peekByName(modelName: any, schemaName: any): any;
-    /**
-     * The one cached Model whose name matches (no hold taken), 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. Takes no hold.
-     */
-    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. Takes no hold.
-     */
-    static findByModelType(modelType: any): any;
-    /**
-     * Get all Model instances for a schema from cache only (synchronous). Takes no holds.
-     * 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. Takes no hold.
-     */
-    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. Takes a hold unless `hold: false`.
-     */
-    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. Takes no holds: a caller that keeps a
-     * model uses `Model.find` or `Model.create`.
-     */
-    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;
-    let schemaHeldModelIds: Set<any>;
-}
-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;
-/**
- * Thrown by Item.create when a File/Image/Html/ItemStorage value couldn't be saved for a reason
- * other than its rules (those throw ItemCreateValidationError). The draft is removed, as for
- * ItemCreateValidationError. `cause` holds the save's own error, e.g. an OwnershipError.
- */
-declare class ItemCreateError extends Error {
-    constructor(message: any, details: any);
-    code: any;
-    modelName: any;
-    property: any;
-    seedLocalId: any;
-}
-/**
- * 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 function finishSchemaDestroy(schemaName: any): void;
-declare function getDraftSaveError(service: any): any;
-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 var Model$1: Readonly<{
-    __proto__: null;
-    Model: typeof Model;
-}>;
-declare var errors: Readonly<{
-    __proto__: null;
-    ItemCreateError: typeof ItemCreateError;
-    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, ItemCreateError as d, setupEntityLiveQuery as e, finishSchemaDestroy as f, getDraftSaveError as g, writeToDatabase$1 as h, Model$1 as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
-//# sourceMappingURL=errors-D1zHAqjr.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors-D1zHAqjr.d.ts","sourceRoot":"","sources":["../errors-D1zHAqjr.js"],"names":[],"mappings":"AAgqDA;;GAEG;AACH;IACI,yCAKC;IAFG,cAAwB;CAG/B;AAysED;;;;;GAKG;AACH;IACI,2CAMC;IAHG,eAA0B;IAC1B,cAAwB;CAG/B;AA/8DD;IACI,gEAOC;IACD,gDAIC;IAsCD;;;OAGG;IACH,iEAuBC;IACD;;;;OAIG;IACH,0DAkBC;IACD;;;;OAIG;IACH,gEAEC;IACD;;;;;;;;OAQG;IACH,0FA4DC;IACD,0EAgiBC;IACD;;;OAGG;IACH,sCAMC;IACD;;;;OAIG;IACH,iDAKC;IACD,gGAAgG;IAChG,8CAEC;IACD,iFAAiF;IACjF,iDAYC;IACD;;;OAGG;IACH,mCAEC;IACD;;;;;;;OAOG;IACH,uDAGC;IACD;;;;OAIG;IACH,wDAMC;IACD;;;OAGG;IACH,4DAcC;IACD;;;OAGG;IACH,gDAcC;IACD;;;;;OAKG;IACH,4CAQC;IACD;;;OAGG;IACH,2DAyBC;IACD;;;OAGG;IACH,8DA6CC;IACD;;;;;;;OAOG;IACH,mFA6DC;IACD;;;;;;OAMG;IACH,gEA6DC;IACD;;;;;OAKG;IACH;;;;;;qBAoBC;IACD;;;;;;OAMG;IACH,+DA4DC;IACD;;;;;;OAMG;IACH,0DA8FC;IACD;;OAEG;IACH,4FAeC;IAkTD;;;;;OAKG;IACH,8CAyCC;IAqSD;;;;OAIG;IACH,0DAkBC;IAl5DD,8FAmCC;IAzBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IA0uCN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD;;;OAGG;IACH;;OA8BC;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;IAiDD;;OAEG;IACH,eA4BC;IACD;;;OAGG;IACH,yBAwEC;IACD;;;OAGG;IACH,oCAsGC;IACD;;OAEG;IACH,0CAkEC;IACD;;OAEG;IACH,mCAEC;CAyBJ;;;;;;;;;;;;AA6BD;;;;;;;;;;;;;;;;;;;;;;;IAA2D;AAiC3D,+FAA+F;AAC/F;IACI,6CAMC;IAHG,eAA0B;IAC1B,gBAA4B;CAGnC;AA3CD,uIAA4D;AA9hG5D;;;GAGG;AACH,uDAEC;AA3ED,gDAEC;AAmnGD;;;;GAIG;AACH;IACI,wCAQC;IALG,UAAwB;IACxB,eAAkC;IAClC,cAAgC;IAChC,iBAAsC;CAG7C;AAruED;;;;;;GAMG;AACH,wEA4JC;AAhjCD,4DAQC;AA4lCD,sDAEC;AA5yBD;;;;GAIG;AA6wFH;;;GAGG;AAgDH;;;;;GAKG;AA7oGH;;;;;GAKG;AACH,4DAGC;AAUD;;;GAGG;AACH,0EAQC;AAklCD,kGAAkG;AAClG,2EAQC;AA/yBD;;;;;;;;;;;;;;;;;;;gCAqLG"}

package/dist/dist/eventBus-7vxTCc3a.d.ts

@@ -1,18 +0,0 @@
-export { eventEmitter as e };
-declare const eventEmitter: SeedEventEmitter;
-declare class SeedEventEmitter {
-    listeners: Map<any, any>;
-    on(event: any, listener: any): this;
-    addListener(event: any, listener: any): this;
-    once(event: any, listener: any): this;
-    off(event: any, listener: any): this;
-    removeListener(event: any, listener: any): this;
-    removeAllListeners(event: any): this;
-    /**
-     * Calls every listener. A listener that throws is logged and skipped: the others still
-     * run, and the error never reaches the SDK code that emitted the event (which may be
-     * midway through a save).
-     */
-    emit(event: any, ...args: any[]): boolean;
-}
-//# sourceMappingURL=eventBus-7vxTCc3a.d.ts.map

package/dist/dist/eventBus-7vxTCc3a.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventBus-7vxTCc3a.d.ts","sourceRoot":"","sources":["../eventBus-7vxTCc3a.js"],"names":[],"mappings":";AA4DA,6CAA4C;AA5D5C;IAEQ,yBAA0B;IAE9B,oCAKC;IACD,6CAEC;IACD,sCAMC;IACD,qCAQC;IACD,gDAEC;IACD,qCAOC;IACD;;;;OAIG;IACH,0CAaC;CACJ"}

package/dist/dist/findSeedRowsByUid-CT3sOXXw.d.ts

@@ -1,13 +0,0 @@
-export { findSeedRowsByUid as f };
-/**
- * The local seed row for each seed attestation uid. A uid recorded on a seed's versions
- * (`versions.seed_uid`) belongs to that seed: its current uid, or an old one from before it was
- * unpublished and published again (the seed row then holds the new uid, the old version rows keep
- * the old one). A uid no version records resolves by `seeds.uid`. Uids with no local seed are left
- * out of the map.
- *
- * Going through versions first also resolves a republished seed's old uid to the item when an
- * older sync left a second, version-less seed row with that uid (migration 0024 removes those).
- */
-declare function findSeedRowsByUid(uids: any): Promise<Map<any, any>>;
-//# sourceMappingURL=findSeedRowsByUid-CT3sOXXw.d.ts.map

package/dist/dist/findSeedRowsByUid-CT3sOXXw.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findSeedRowsByUid-CT3sOXXw.d.ts","sourceRoot":"","sources":["../findSeedRowsByUid-CT3sOXXw.js"],"names":[],"mappings":";AAIA;;;;;;;;;GASG;AACH,sEA6BC"}

package/dist/dist/getItem-Bhjecbia.d.ts

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

package/dist/dist/getItem-Bhjecbia.d.ts.map

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

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

@@ -1,47 +0,0 @@
-/** 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-DH4rMqXG.d.ts.map

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

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