@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/dist/Item-CG5IhPtL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Item-CG5IhPtL.d.ts","sourceRoot":"","sources":["../Item-CG5IhPtL.js"],"names":[],"mappings":"AA4EA,mDAEC;AAk0DD;;;;;GAKG;AACH;;;;UAuBC;AAkMD,wGAAwG;AACxG,uFAIC;AAgrHD;;;GAGG;AACH;IACI,8CAKC;IAHG,kBAAgC;IAChC,cAAwB;CAG/B;AA3sHD;;;GAGG;AACH,yFAMC;AA9LD;;;;;;;GAOG;AACH;;;;iBA+IC;AArjED;;;;;GAKG;AACH,6EA8CC;AAmhED,sFAAsF;AACtF,gEASC;AAfD;;;GAGG;AACH,mDAAyI;AAw/KzI;IA4QI,oGAAoG;IACpG,0DAcC;IACD,oDAUC;IACD,iEAOC;IACD,wDAcC;IACD;;;;OAIG;IACH,uCAmCC;IAiDD;;;;OAIG;IACH,2EA0BC;IACD,8FAA8F;IAC9F,4DAaC;IACD;;;OAGG;IACH,sDAWC;IACD;;;OAGG;IACH,0BAEC;IACD;;;;OAIG;IACH,+BAUC;IACD;;;OAGG;IACH,oFA2CC;IACD,kFAeC;IACD,sDA0NC;IACD;;;;OAIG;IACH,sEAqBC;IACD;;;;OAIG;IACH,uFA8BC;IACD,yFAgBC;IACD;;;;;OAKG;IACH,6BAUC;IACD;;;OAGG;IACH,qDA4BC;IACD;;;;;;;OAOG;IACH,sEAwBC;IACD;;;;;;qBA8BC;IACD,uEAkBC;IACD;;;;OAIG;IACH,+DAsHC;IAmBD,sGAAsG;IACtG,0HAwDC;IACD;;;OAGG;IACH,2EAcC;IACD,uDAEC;IAzrCD,gCA0QC;IAzQG,wCAAiD;IACjD,4DAIC;IACD;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;OAGG;IACH,gCAKC;IACD,wCAKC;IACD,+BA+BC;IACD;;;;;;;;;;OAUG;IACH,wCAsCC;IACD,oDAOC;IACD,6EAMC;IACD,+EAsBC;IAMG,2BAA+D;IAEnE;;;;;;;;;;;;;;;;;;;;;;;qCAcE;IACF,6CAgBE;IA8KN;;;OAGG;IACH,8CAWC;IACD,4FAA4F;IAC5F,gCAcC;IACD;;;OAGG;IACH,oCAWC;IAmsBD,0CAiBC;IAiFD,yBAGC;IACD;;;OAGG;IACH,0BAEC;IAID,uBAEC;IACD,mBAEC;IACD,qBAEC;IACD,4BAEC;IACD,gCAEC;IACD,qBAEC;IACD,qBAEC;IACD,qBAEC;IACD,yBAGC;IACD;;;;;OAKG;IACH,+CAiCC;IACD;;;;;OAKG;IACH,6BAiDC;IACD,mEAmBC;IACD;;;;;;;OAOG;IACH,sDAmBC;IACD;;;OAGG;IACH,wBAuBC;IACD;;;OAGG;IACH;;MAGC;IACD;;;OAGG;IACH,wBAEC;IACD,gCAEC;IACD,yBAEC;IACD,kCAEC;IACD,qBAWC;IACD;;;OAGG;IACH,oCAuVC;IACD;;;OAGG;IACH,eA+BC;IACD;;OAEG;IACH,yBA8BC;CACJ;;;;;AAxySD,sDAEC;AAirID;;;;;GAKG;AACH,uEAoDC;AAvxCD;;GAEG;AACH,kEAgBC;AArrFD;;;;;;;;;;;;;;;GAeG;AACH,+CAAwC,kEAAkE,CAAC;AAtG3G;;;GAGG;AACH,2DAA4E;AAk5B5E,sEAAsE;AACtE,+BAAwB,EAAE,CAAC;AAnlC3B;;;;GAIG;AACH,qDAEC;AA3JD;;;GAGG;AACH,wCAAiC,KAAK,CAAC;AA6KvC;;;;;;;;;;;;;;GAcG;AACH,uDAsFC;AAhJD;;;GAGG;AACH;;GAEG;AACH;;;GAGG;AACH,qDAEC;AA2rOD;;;;;;;GAOG;AACH,kFAkCC;AA7zDD;;;GAGG;AACH,yEAcC;AACD;;;;;;GAMG;AACH,gFAkBC;AAlwKD,gEAAgE;AAChE,0EAAkE;AAlElE,oCAAuB;AAZvB,4BAAe;AA3Lf,8CAAuC,mKAAmK,CAAC;AAmpO3M;;;;GAIG;AACH;;;;;;;;GAuFC;AA/hMD;;;GAGG;AACH;;;;;;GAOC;AAr2BD;;;GAGG;AACH;;;QA2BC;AAxZD,2CAEC;AAeD,0CAEC;AAVD,sCAAsC;AACtC,0CAEC;AAkQD;;;;;;;;;;;GAWG;AACH,yCA2CC;AAyyDD;;GAEG;AACH,yDASC;AAQD;;;;;GAKG;AACH,wEAKC;AAyBD,2DAA2D;AAC3D,yFAEC;AAfD;;;GAGG;AACH,wFAEC;AAUD;;;;;;GAMG;AACH,oGAOC;AA70DD,qGAAqG;AACrG,oEAWC;AA0yDD,uGAAuG;AACvG,gGAEC;AAy0FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAmTG;AAlpGH;;;;GAIG;AACH,wGAMC;AA9BD,8DAA8D;AAC9D,qFAKC;AA5mED,+DAEC;AArDD,+DAEC;AAyBD,yDAEC;AAeD,wDAEC;AAXD,sCAAsC;AACtC,wDAEC;AA65KD;;;;;;;GAOG;AACH;IAEQ,6BAA2B;IAE/B,wBAEC;IACD,qCAGC;IACD,+BAEC;IACD,4BAEC;CACJ;AAED;;;GAGG;AACH;;;GAGG;AACH,6EAwBC;AAvID;;;;;;GAMG;AACH,gEAmEC;AA5sKD,qCAAwB;AA4jFxB;;;;GAIG;AACH,4EAgBC;AAnrCD,2FAA2F;AAC3F,wDAA4G;AAmqF5G;;;;+BAgBC;AA39CD,4GAoHC;AA8zBD;;;;;;;;;;;;;;;;;;;;;eAwKC;AAz0DD,2FAA2F;AAC3F,4DAaC;AAuuGD;;;;;;;;GAGG;AAq/HH;;;GAGG;AAxzPH;;;GAGG;AACH,0DAoCC;AAnYD,uEAAuE;AACvE,6DAqBC;AA/CD,sDAAsD;AACtD,mCAA4B,CAAC,CAAC;AAK9B,kEAAkE;AAClE,4CAAkD;AAClD,+EAA+E;AAC/E,mDAA6D;AAya7D,gEAAgE;AAChE,wDAIC;AAzbD,+FAA+F;AAC/F,+CAA0D;AAjC1D;;;;GAIG;AACH;IACI,0BAGC;CACJ;AAUD,uFAAuF;AACvF;IACI,uDAQC;IAJG,UAAgB;IAChB,eAA0B;IAC1B,aAA8B;CAGrC;AAlBD,+FAA+F;AAC/F;IACI,wCAGC;CACJ;AA0JD;;;GAGG;AACH,8CAiBC;AAmXD;;;GAGG;AACH,uFAEC;AA7dD,qCAAqC;AACrC,6CAEC;AACD,sDAAsD;AACtD,8CAEC;AAqDD;;;;;GAKG;AACH,yDAYC;AA+6ID;IAupBI,6CAiIC;IACD;;;OAGG;IACH,uCAeC;IACD;;;;OAIG;IACH;;;;YAiBC;IACD,2EAA2E;IAC3E;;;;;;;;qBA8CC;IACD;;;;OAIG;IACH,sDAqFC;IACD;;;OAGG;IACH,sCAOC;IACD;;;;OAIG;IACH,+CAmBC;IACD,kEAGC;IACD;;;;OAIG;IACH,8DAiBC;IA7gCD,gCAkQC;IAjQG,qBAAwB;IACxB,iBAAoB;IACpB,+BAA6B;IAU7B,8BAA4C;IA6BxC,eAAiE;IAYzD,YAA0B;IAsBtC,+BAAkD;IAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAKF,6CAoKE;IArGM,gBAAmC;IAgH/C;;;OAGG;IACH,oCAsQC;IACD;;;;OAIG;IACH,sCAkIC;IAyXD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,mBAEC;IACD,eAEC;IACD,uBAEC;IACD,mBAEC;IACD,qBAEC;IACD,wBAcC;IACD,uHAAuH;IACvH,+BAEC;IACD,qBAEC;IACD,uBAEC;IACD,2BASC;IACD,4BAEC;IACD,2CAKC;IACD,0BAEC;IACD;;MAEC;IACD,wHAAwH;IACxH,gCAEC;IACD,iBAEC;IACD;;;;OAIG;IACH,oBAEC;IACD;;;OAGG;IACH,4CAkBC;IAiBD,sBAOC;IAvBD,iBAeC;IASD;;;;;;OAMG;IACH,yCAWC;IAPG;;;;;;;kBAA+B;IAQnC;;;;;;;;;OASG;IACH,mCAWC;IACD,4FAA4F;IAC5F,yCAIC;IACD,iGAAiG;IACjG,qDAkCC;IATO,iDAAiC;IAUzC;;;;OAIG;IACH,4BAMC;IACD,yBAEC;IACD,wDASC;IACD,sBAoCC;IACD;;;OAGG;IACH,oBAOC;IACD,eAwCC;IACD;;;;OAIG;IACH,yBAwBC;IACD,0CAkDC;CACJ;;;;;AA19LD,iFAAiF;AACjF,4EAMC;AAwDD;;;GAGG;AACH,qCAWC;AAu7ID,4GAA4G;AAC5G;IACI,iDAIC;IAFG,sBAAwC;CAG/C;AAnoHD;;;GAGG;AACH;IACI,8BAIC;CACJ;AAsID;;;GAGG;AACH,2DAKC;AAlpBD;;;GAGG;AACH,0DAgBC;AAqmBD;;;;;;;;GAQG;AACH,0DAMC;AAr2DD,wFAAwF;AACxF,wEAMC;AA0vBD;;;;GAIG;AACH,2DAAuG;gCA1sCvE,MAAM"}

package/dist/dist/ModelProperty-DDD47KVm.d.ts

@@ -1,315 +0,0 @@
-export class ModelProperty {
-    static create(property: any, options: any): any;
-    /** Whether an idIndex entry still points at a cached instance with that id. */
-    static isIndexEntryCurrent(propertyFileId: any, entry: any): boolean;
-    /** Add a newly cached instance to idIndex, and keep its entry current when its id changes. */
-    static indexCachedInstance(cacheKey: any, instance: any): void;
-    /**
-     * Turns the caller's hold from the create call just made into model ownership: the instance stays
-     * cached and running for its model, and app holders' unload calls don't stop it.
-     * @internal Used by the model's property loading.
-     */
-    static adoptForModel(instance: any): void;
-    /**
-     * Get ModelProperty instance by propertyFileId from static cache
-     */
-    static getById(propertyFileId: any): any;
-    /**
-     * Create or get ModelProperty instance by propertyFileId
-     * Queries the database to find the property if not cached
-     */
-    static createById(propertyFileId: any, options: any): Promise<any>;
-    /**
-     * Give cached instances of these properties the values their rows now have (e.g. after a schema
-     * update reloaded them: renamed, dataType or storage changed). Nothing else updates them: createById
-     * and the Model's property refresh return a cached instance as is. A renamed instance's
-     * "modelName:oldName" cache entry is re-keyed so creating the property by its new name finds it.
-     * Instances with unsaved edits are left alone, as addModelsToDb leaves edited rows alone.
-     */
-    static refreshFromDb(propertyFileIds: any): Promise<void>;
-    /**
-     * Find ModelProperty instance by propertyFileId
-     * Waits for the property to be fully loaded (idle state) by default
-     * @param options - Find options including propertyFileId and wait configuration
-     * @returns ModelProperty instance if found, undefined otherwise
-     */
-    static find({ propertyFileId, waitForReady, readyTimeout, }: {
-        propertyFileId: any;
-        waitForReady?: boolean | undefined;
-        readyTimeout?: number | undefined;
-    }): Promise<any>;
-    /**
-     * Get all ModelProperty instances for a model.
-     * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
-     */
-    static all(modelFileId: any, options: any): Promise<any[]>;
-    /**
-     * Track a pending write for a property
-     */
-    static trackPendingWrite(propertyFileId: any, modelId: any): void;
-    /**
-     * A property write succeeded: add the property to its model's property ids, then drop the pending
-     * write. In that order, `Model.properties` (property ids + pending writes) never misses it; in Node,
-     * where the Model has no reactive liveQuery, nothing else would add it.
-     */
-    static completePendingWrite(propertyFileId: any, modelId: any): Promise<void>;
-    /**
-     * Clear or update pending write status
-     */
-    static clearPendingWrite(propertyFileId: any, status?: string): void;
-    /**
-     * Get all pending property IDs for a model
-     */
-    static getPendingPropertyIds(modelId: any): any[];
-    /**
-     * Get modelId for a property that has a pending write (row may not be in DB yet).
-     * Used to resolve modelName when validating a just-created property rename.
-     */
-    static getPendingModelId(propertyFileId: any): any;
-    /**
-     * Force-evict cached ModelProperty instances for the given models, ignoring refCounts, and stop
-     * their services. Used by Schema.destroy() so a re-imported schema gets fresh instances instead of
-     * ones holding a deleted row's _dbId.
-     */
-    static evictForModels(modelNames: any, schemaName: any): void;
-    constructor(property: any);
-    /** currentEvictionEpoch() at construction: lookups started for this instance don't outlive an eviction. */
-    _evictionEpoch: number;
-    _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: "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;
-    } | {
-        src: "saveToSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "compareAndMarkDraft";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "validateProperty";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        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>>;
-    /**
-     * Send from fire-and-forget async work (DB lookups started in the constructor), which can finish
-     * after the instance was unloaded or evicted with its schema.
-     */
-    _sendIfRunning(event: any): void;
-    /**
-     * Initialize original values and schema name for tracking changes
-     * This is called asynchronously after construction
-     * If the property was loaded from the database and differs from the schema file,
-     * it will be marked as edited.
-     */
-    _initializeOriginalValues(property: any): void;
-    /**
-     * Load isEdited flag from database if property exists in DB
-     * @param property - The property data
-     * @param fallbackIsEdited - Fallback value if property doesn't exist in DB
-     * @returns The isEdited flag from database or fallback value
-     */
-    _loadIsEditedFromDb(property: any, fallbackIsEdited: any): Promise<any>;
-    /**
-     * Resolve refModelId from refModelName by querying the database
-     * @param refModelName - The name of the referenced model
-     * @returns The database ID of the referenced model, or undefined if not found
-     */
-    _resolveRefModelId(refModelName: any, property: any): Promise<any>;
-    /** Which model this property belongs to: its models row id and/or schema. */
-    _ownerModelScope(property: any): {
-        modelId: number | undefined;
-        schemaName: any;
-    };
-    /**
-     * Get schema file values for this property to use as "original" values
-     * This allows comparison with database values to detect edits
-     */
-    _getSchemaFileValues(property: any): Promise<{
-        name: any;
-        modelName: any;
-        dataType: any;
-        storageType: any;
-        localStorageDir: any;
-        filenameSuffix: any;
-    } | undefined>;
-    /**
-     * Set the schema name for this property by looking it up from the model
-     * Tries database first (more reliable), then falls back to schema files
-     */
-    _setSchemaName(property: any): Promise<void>;
-    /**
-     * Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished).
-     * Uses context.id (schemaFileId) and context.modelId to query properties → model_schemas → schemas.
-     */
-    _resolveSchemaNameForDestroy(db: any, context: any): Promise<any>;
-    /**
-     * Manually set the schema name for this property
-     * Useful when you know the schema name from context (e.g., when working with Schema instances)
-     */
-    setSchemaName(schemaName: any): void;
-    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: "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;
-    } | {
-        src: "saveToSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "compareAndMarkDraft";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "validateProperty";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        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(): {};
-    get path(): string | undefined;
-    get status(): {};
-    get isEdited(): any;
-    get validationErrors(): any;
-    get isValid(): boolean;
-    /**
-     * Validate the property
-     * @returns Validation result
-     */
-    validate(): Promise<any>;
-    save(): void;
-    /**
-     * Reload property from database
-     * This refreshes the actor context with the latest data from the database
-     * Note: ModelProperty doesn't have a dedicated load actor, so this will
-     * re-initialize from the current property data
-     */
-    reload(): Promise<void>;
-    /**
-     * Releases this caller's hold. The instance is shared: it keeps running while other callers hold
-     * it, or while its model owns it (a model's properties are stopped when the model is evicted).
-     * An instance nobody else holds is stopped and leaves the cache.
-     */
-    unload(): void;
-    /**
-     * Destroy the model property: remove from caches, delete from database, update Schema context, stop service.
-     */
-    destroy(): Promise<void>;
-}
-export namespace ModelProperty {
-    let instanceCache: Map<any, any>;
-    let idIndex: Map<any, any>;
-    let pendingWrites: Map<any, any>;
-}
-//# sourceMappingURL=ModelProperty-DDD47KVm.d.ts.map

package/dist/dist/ModelProperty-DDD47KVm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelProperty-DDD47KVm.d.ts","sourceRoot":"","sources":["../ModelProperty-DDD47KVm.js"],"names":[],"mappings":"AA41BA;IAyZI,gDA+RC;IACD,+EAA+E;IAC/E,qEAUC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAyEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAvpCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA8EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IA2nBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}