@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/src/ModelProperty/ModelProperty.d.ts

@@ -0,0 +1,112 @@
+import { ActorRefFrom } from 'xstate';
+import { Static } from '@sinclair/typebox';
+import { ModelPropertyDataTypes, TProperty } from '@/Schema';
+import { modelPropertyMachine } from './service/modelPropertyMachine';
+import { StorageType } from '@/types';
+type ModelPropertyService = ActorRefFrom<typeof modelPropertyMachine>;
+export declare class ModelProperty {
+    protected static instanceCache: Map<string, {
+        instance: ModelProperty;
+        refCount: number;
+    }>;
+    private static pendingWrites;
+    protected readonly _service: ModelPropertyService;
+    name?: string;
+    dataType?: ModelPropertyDataTypes;
+    ref?: string;
+    modelId?: number;
+    modelName?: string;
+    refModelId?: number;
+    refModelName?: string;
+    refValueType?: ModelPropertyDataTypes;
+    storageType?: StorageType;
+    localStorageDir?: string;
+    filenameSuffix?: string;
+    constructor(property: Static<typeof TProperty>);
+    /**
+     * 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.
+     */
+    private _initializeOriginalValues;
+    /**
+     * 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
+     */
+    private _loadIsEditedFromDb;
+    /**
+     * 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
+     */
+    private _resolveRefModelId;
+    /**
+     * Get schema file values for this property to use as "original" values
+     * This allows comparison with database values to detect edits
+     */
+    private _getSchemaFileValues;
+    /**
+     * 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
+     */
+    private _setSchemaName;
+    /**
+     * 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: string): void;
+    static create(property: Static<typeof TProperty>): ModelProperty;
+    /**
+     * Get ModelProperty instance by propertyFileId from static cache
+     */
+    static getById(propertyFileId: string): ModelProperty | undefined;
+    /**
+     * Create or get ModelProperty instance by propertyFileId
+     * Queries the database to find the property if not cached
+     */
+    static createById(propertyFileId: string): Promise<ModelProperty | undefined>;
+    /**
+     * Track a pending write for a property
+     */
+    static trackPendingWrite(propertyFileId: string, modelId: number): void;
+    /**
+     * Clear or update pending write status
+     */
+    static clearPendingWrite(propertyFileId: string, status?: 'success' | 'error'): void;
+    /**
+     * Get all pending property IDs for a model
+     */
+    static getPendingPropertyIds(modelId: number): string[];
+    getService(): ModelPropertyService;
+    private _getSnapshot;
+    private _getSnapshotContext;
+    get path(): string | undefined;
+    get status(): "idle" | "compareAndMarkDraft" | "validating" | {
+        saveToSchema: "saving";
+    };
+    get isEdited(): boolean;
+    get validationErrors(): import("@/Schema").ValidationError[];
+    get isValid(): boolean;
+    /**
+     * Validate the property
+     * @returns Validation result
+     */
+    validate(): Promise<{
+        isValid: boolean;
+        errors: 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>;
+    unload(): void;
+}
+export {};
+//# sourceMappingURL=ModelProperty.d.ts.map

package/dist/src/ModelProperty/ModelProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelProperty.d.ts","sourceRoot":"","sources":["../../../src/ModelProperty/ModelProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA6B,MAAM,QAAQ,CAAA;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC5D,OAAO,EAAE,oBAAoB,EAA+B,MAAM,gCAAgC,CAAA;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAOrC,KAAK,oBAAoB,GAAG,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAmBrE,qBAAa,aAAa;IACxB,SAAS,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CACjC,MAAM,EACN;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAC9C,CAAY;IAGb,OAAO,CAAC,MAAM,CAAC,aAAa,CAKxB;IAEJ,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAA;IAEjD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,sBAAsB,CAAA;IACjC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,sBAAsB,CAAA;IACrC,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;gBAEX,QAAQ,EAAE,MAAM,CAAC,OAAO,SAAS,CAAC;IAoB9C;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;IAoHjC;;;;;OAKG;YACW,mBAAmB;IAmDjC;;;;OAIG;YACW,kBAAkB;IAiChC;;;OAGG;YACW,oBAAoB;IAsDlC;;;OAGG;YACW,cAAc;IAqD5B;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOvC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,SAAS,CAAC,GAAG,aAAa;IAyQhE;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAgBjE;;;OAGG;WACU,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAwGnF;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IASvE;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,GAAE,SAAS,GAAG,OAAmB,GAAG,IAAI;IAgB/F;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAQvD,UAAU,IAAI,oBAAoB;IAIlC,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,mBAAmB;IAI3B,IAAI,IAAI,uBAMP;IAED,IAAI,MAAM;;MAET;IAED,IAAI,QAAQ,YAcX;IAED,IAAI,gBAAgB,yCAEnB;IAED,IAAI,OAAO,YAGV;IAED;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IAkC9D,IAAI,IAAI,IAAI;IAOZ;;;;;OAKG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAS7B,MAAM,IAAI,IAAI;CAGf"}

package/dist/src/ModelProperty/service/actors/compareAndMarkDraft.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelPropertyMachineContext } from '../modelPropertyMachine';
+export declare const compareAndMarkDraft: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelPropertyMachineContext>, EventObject>;
+//# sourceMappingURL=compareAndMarkDraft.d.ts.map

package/dist/src/ModelProperty/service/actors/compareAndMarkDraft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareAndMarkDraft.d.ts","sourceRoot":"","sources":["../../../../../src/ModelProperty/service/actors/compareAndMarkDraft.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAOrE,eAAO,MAAM,mBAAmB,+GAiI9B,CAAA"}

package/dist/src/ModelProperty/service/actors/saveToSchema.d.ts

@@ -0,0 +1,11 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelPropertyMachineContext } from '../modelPropertyMachine';
+/**
+ * Get schema name from model
+ * This function finds which schema contains the given model
+ * Exported so it can be reused by ModelProperty for setting schema name
+ */
+export declare function getSchemaNameFromModel(modelName: string): Promise<string | undefined>;
+export declare const saveToSchema: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelPropertyMachineContext>, EventObject>;
+//# sourceMappingURL=saveToSchema.d.ts.map

package/dist/src/ModelProperty/service/actors/saveToSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveToSchema.d.ts","sourceRoot":"","sources":["../../../../../src/ModelProperty/service/actors/saveToSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAQrE;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAqB3F;AAED,eAAO,MAAM,YAAY,+GAmGvB,CAAA"}

package/dist/src/ModelProperty/service/actors/validateProperty.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { ModelPropertyMachineContext } from '../modelPropertyMachine';
+export declare const validateProperty: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ModelPropertyMachineContext>, EventObject>;
+//# sourceMappingURL=validateProperty.d.ts.map

package/dist/src/ModelProperty/service/actors/validateProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateProperty.d.ts","sourceRoot":"","sources":["../../../../../src/ModelProperty/service/actors/validateProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAA;AAUrE,eAAO,MAAM,gBAAgB,+GAyI3B,CAAA"}

package/dist/src/ModelProperty/service/modelPropertyMachine.d.ts

@@ -0,0 +1,183 @@
+import { ActorRefFrom } from 'xstate';
+import { Static } from '@sinclair/typebox';
+import { TProperty } from '@/Schema';
+import { ValidationError } from '@/Schema/validation';
+import { writeProcessMachine } from '@/services/write/writeProcessMachine';
+export type ModelPropertyMachineContext = Static<typeof TProperty> & {
+    _originalValues?: Partial<Static<typeof TProperty>>;
+    _isEdited?: boolean;
+    _schemaName?: string;
+    _validationErrors?: ValidationError[];
+    writeProcess?: ActorRefFrom<typeof writeProcessMachine> | null;
+    _propertyFileId?: string;
+};
+export declare const modelPropertyMachine: import("xstate").StateMachine<ModelPropertyMachineContext, {
+    [key: string]: any;
+    type: "updateContext";
+} | {
+    type: "initializeOriginalValues";
+    originalValues: Partial<Static<typeof TProperty>>;
+    schemaName?: string;
+    isEdited?: boolean;
+} | {
+    type: "clearEdited";
+} | {
+    type: "setSchemaName";
+    schemaName: string;
+} | {
+    type: "saveToSchema";
+} | {
+    type: "saveToSchemaSuccess";
+} | {
+    type: "saveToSchemaError";
+    error: Error;
+} | {
+    type: "compareAndMarkDraftSuccess";
+} | {
+    type: "compareAndMarkDraftError";
+} | {
+    type: "validateProperty";
+} | {
+    type: "validationSuccess";
+    errors: ValidationError[];
+} | {
+    type: "validationError";
+    errors: ValidationError[];
+} | {
+    type: "requestWrite";
+    data: any;
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<import("@/services/write/writeProcessMachine").WriteProcessContext, {
+        type: "startWrite";
+        data: any;
+    } | {
+        type: "validate";
+    } | {
+        type: "write";
+    } | {
+        type: "writeSuccess";
+        output?: any;
+    } | {
+        type: "writeError";
+        error: Error;
+    } | {
+        type: "retry";
+    } | {
+        type: "revert";
+    } | {
+        type: "reset";
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeToDatabase";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelPropertyMachineContext>, import("xstate").EventObject>> | undefined;
+}, {
+    src: "saveToSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelPropertyMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateProperty";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelPropertyMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "compareAndMarkDraft";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelPropertyMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeProcessMachine";
+    logic: import("xstate").StateMachine<import("@/services/write/writeProcessMachine").WriteProcessContext, {
+        type: "startWrite";
+        data: any;
+    } | {
+        type: "validate";
+    } | {
+        type: "write";
+    } | {
+        type: "writeSuccess";
+        output?: any;
+    } | {
+        type: "writeError";
+        error: Error;
+    } | {
+        type: "retry";
+    } | {
+        type: "revert";
+    } | {
+        type: "reset";
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: import("xstate").PromiseActorLogic<import("../../services/write/actors/validateEntity").ValidateEntityInput, {
+            isValid: boolean;
+            errors: ValidationError[];
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeToDatabase";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>;
+    id: string | undefined;
+}, {
+    type: "assignValidationErrors";
+    params: import("xstate").NonReducibleUnknown;
+}, {
+    type: "isPropertyValid";
+    params: unknown;
+} | {
+    type: "hasValidationErrors";
+    params: unknown;
+}, never, "idle" | "compareAndMarkDraft" | "validating" | {
+    saveToSchema: "saving";
+}, string, ModelPropertyMachineContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "modelProperty";
+    states: {
+        readonly idle: {};
+        readonly validating: {};
+        readonly compareAndMarkDraft: {};
+        readonly saveToSchema: {
+            states: {
+                readonly saving: {};
+            };
+        };
+    };
+}>;
+//# sourceMappingURL=modelPropertyMachine.d.ts.map

package/dist/src/ModelProperty/service/modelPropertyMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelPropertyMachine.d.ts","sourceRoot":"","sources":["../../../../src/ModelProperty/service/modelPropertyMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,YAAY,EAAE,MAAM,QAAQ,CAAA;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAIpC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAA;AAE1E,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,OAAO,SAAS,CAAC,GAAG;IAEnE,eAAe,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC,CAAA;IAEnD,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAA;IACrC,YAAY,CAAC,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAE9D,eAAe,CAAC,EAAE,MAAM,CAAA;CAGzB,CAAA;AAED,eAAO,MAAM,oBAAoB;;UAKjB,eAAe;;UACf,0BAA0B;oBAAkB,OAAO,CAAC,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;iBAAe,MAAM;eAAa,OAAO;;UACtH,aAAa;;UACb,eAAe;gBAAc,MAAM;;UACnC,cAAc;;UACd,qBAAqB;;UACrB,mBAAmB;WAAS,KAAK;;UACjC,4BAA4B;;UAC5B,0BAA0B;;UAC1B,kBAAkB;;UAClB,mBAAmB;YAAU,eAAe,EAAE;;UAC9C,iBAAiB;YAAU,eAAe,EAAE;;UAC5C,cAAc;UAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2QvC,CAAA"}

package/dist/src/Schema/Schema.d.ts

@@ -0,0 +1,143 @@
+import { ActorRefFrom } from 'xstate';
+import { schemaMachine } from './service/schemaMachine';
+import { Model } from '@/Model/Model';
+type SchemaService = ActorRefFrom<typeof schemaMachine>;
+/**
+ * Options for Schema.all() method
+ */
+export interface SchemaAllOptions {
+    /**
+     * If true, returns all versions of each schema. If false (default), returns only the latest version of each schema.
+     * @default false
+     */
+    includeAllVersions?: boolean;
+    /**
+     * If true, includes the internal Seed Protocol schema. If false (default), excludes it.
+     * @default false
+     */
+    includeInternal?: boolean;
+}
+export declare class Schema {
+    protected static instanceCacheById: Map<string, {
+        instance: Schema;
+        refCount: number;
+    }>;
+    protected static instanceCacheByName: Map<string, {
+        instance: Schema;
+        refCount: number;
+    }>;
+    protected static savingSchemas: Set<string>;
+    protected readonly _service: SchemaService;
+    $schema?: string;
+    version?: number;
+    metadata?: {
+        name: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    models?: Model[];
+    enums?: {
+        [enumName: string]: any;
+    };
+    migrations?: Array<{
+        version: number;
+        timestamp: string;
+        description: string;
+        changes: any[];
+    }>;
+    constructor(schemaName: string);
+    static create(schemaName: string): Schema;
+    /**
+     * Update the cache to use schemaFileId as the key instead of schemaName
+     * This should be called once the schema is loaded and we have the schemaFileId
+     * We keep the instance in BOTH caches for efficient lookups by either name or ID
+     */
+    private static _updateCacheKey;
+    /**
+     * Get schema instance by schemaFileId (preferred method)
+     * Returns null if not found in cache
+     */
+    static getById(schemaFileId: string): Schema | null;
+    /**
+     * Clear all cached Schema instances.
+     * This is primarily useful for test cleanup.
+     * All cached instances will be unloaded and removed from both caches.
+     */
+    static clearCache(): void;
+    /**
+     * Create or get schema instance by schemaFileId
+     * Queries the database to find the schema name if not cached
+     * @param schemaFileId - The schema file ID
+     * @returns Schema instance
+     */
+    static createById(schemaFileId: string): Promise<Schema>;
+    /**
+     * Get instantiated Schema objects for all schemas (from database and files)
+     * By default, returns only the latest version of each schema and excludes the internal Seed Protocol schema.
+     * Uses loadAllSchemasFromDb() as the single source of truth, which intelligently merges database and file data.
+     *
+     * @param options - Configuration options
+     * @param options.includeAllVersions - If true, returns all versions of each schema. Default: false
+     * @param options.includeInternal - If true, includes the internal Seed Protocol schema. Default: false
+     * @returns Array of Schema instances
+     */
+    static all(options?: SchemaAllOptions): Promise<Schema[]>;
+    getService(): SchemaService;
+    private _getSnapshot;
+    private _getSnapshotContext;
+    get schemaName(): string;
+    get schemaFileId(): string | undefined;
+    get id(): string | undefined;
+    get status(): "idle" | "error" | "validating" | "addingModels" | {
+        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+    };
+    get isEdited(): boolean;
+    get validationErrors(): import("./validation").ValidationError[];
+    get isValid(): boolean;
+    /**
+     * Validate the schema
+     * @returns Validation result
+     */
+    validate(): Promise<{
+        isValid: boolean;
+        errors: any[];
+    }>;
+    /**
+     * Build models object from Model instances (for persistence)
+     * Model instances are the source of truth for model data
+     */
+    private _buildModelsFromInstances;
+    /**
+     * Saves all edited properties to a new schema version.
+     * This writes the changes to a new JSON file and clears the draft flags.
+     * Validates the schema before saving.
+     * Transitions schema from draft (DB-only) to published (file + DB).
+     * @returns The file path of the new schema version
+     */
+    saveNewVersion(): Promise<string>;
+    /**
+     * Check for conflicts between actor context and database
+     * @returns ConflictResult indicating if a conflict exists
+     */
+    private _checkForConflicts;
+    /**
+     * Reload schema from database
+     * This refreshes the actor context with the latest data from the database
+     */
+    reload(): Promise<void>;
+    /**
+     * Save the current schema state to the database as a draft
+     * This persists changes immediately without creating a new file version
+     * @param oldName - Optional old name to look up existing record before name change
+     * @param newName - Optional new name to use (if not provided, uses this.schemaName)
+     */
+    private _saveDraftToDb;
+    unload(): void;
+    /**
+     * Set up liveQuery subscription to watch for model changes in the database
+     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
+     */
+    private _setupLiveQuerySubscription;
+}
+export {};
+//# sourceMappingURL=Schema.d.ts.map

package/dist/src/Schema/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../src/Schema/Schema.ts"],"names":[],"mappings":"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"}

package/dist/src/Schema/errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Conflict detection result
+ */
+export type ConflictResult = {
+    hasConflict: boolean;
+    localVersion?: number;
+    dbVersion?: number;
+    localUpdatedAt?: string;
+    dbUpdatedAt?: string;
+    message?: string;
+};
+/**
+ * Error thrown when a conflict is detected between actor context and database
+ */
+export declare class ConflictError extends Error {
+    readonly conflict: ConflictResult;
+    readonly name = "ConflictError";
+    constructor(message: string, conflict: ConflictResult);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/Schema/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/Schema/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,OAAO,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,QAAQ,EAAE,cAAc,CAAA;IACxC,SAAgB,IAAI,mBAAkB;gBAE1B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc;CAKtD"}

package/dist/src/Schema/index.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export * from '../Model';
+export * from '../helpers/property/index';
+export * from '../helpers/property';
+export * from './validation';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAA;AAEzB,cAAc,UAAU,CAAA;AACxB,cAAc,2BAA2B,CAAA;AACzC,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA"}

package/dist/src/Schema/service/actors/checkExistingSchema.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { SchemaMachineContext } from '../schemaMachine';
+export declare const checkExistingSchema: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<SchemaMachineContext>, EventObject>;
+//# sourceMappingURL=checkExistingSchema.d.ts.map

package/dist/src/Schema/service/actors/checkExistingSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkExistingSchema.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/checkExistingSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AA4FvD,eAAO,MAAM,mBAAmB,wGA6Z9B,CAAA"}

package/dist/src/Schema/service/actors/createModelInstances.d.ts

@@ -0,0 +1,11 @@
+import { EventObject } from 'xstate';
+export type CreateModelInstancesInput = {
+    modelIds: string[];
+    schemaName: string;
+};
+/**
+ * Create Model instances for all model IDs to ensure they're cached
+ * This ensures that Model.getById() in Schema.getContext() will find the instances
+ */
+export declare const createModelInstances: import("xstate").CallbackActorLogic<EventObject, CreateModelInstancesInput, EventObject>;
+//# sourceMappingURL=createModelInstances.d.ts.map

package/dist/src/Schema/service/actors/createModelInstances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createModelInstances.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/createModelInstances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAKlD,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,0FAmE/B,CAAA"}

package/dist/src/Schema/service/actors/createPropertyInstances.d.ts

@@ -0,0 +1,12 @@
+import { EventObject } from 'xstate';
+export type CreatePropertyInstancesInput = {
+    propertyIds: string[];
+    modelIds: string[];
+};
+/**
+ * Create ModelProperty instances for all property IDs to ensure they're cached
+ * Properties are typically created when Model instances are created, but this
+ * ensures they're all available in the cache
+ */
+export declare const createPropertyInstances: import("xstate").CallbackActorLogic<EventObject, CreatePropertyInstancesInput, EventObject>;
+//# sourceMappingURL=createPropertyInstances.d.ts.map

package/dist/src/Schema/service/actors/createPropertyInstances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyInstances.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/createPropertyInstances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAKlD,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,6FAmFlC,CAAA"}

package/dist/src/Schema/service/actors/loadOrCreateSchema.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { SchemaMachineContext } from '../schemaMachine';
+export declare const loadOrCreateSchema: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<SchemaMachineContext>, EventObject>;
+//# sourceMappingURL=loadOrCreateSchema.d.ts.map

package/dist/src/Schema/service/actors/loadOrCreateSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadOrCreateSchema.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/loadOrCreateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAkLvD,eAAO,MAAM,kBAAkB,wGA8zC7B,CAAA"}

package/dist/src/Schema/service/actors/validateSchema.d.ts

@@ -0,0 +1,5 @@
+import { EventObject } from 'xstate';
+import { FromCallbackInput } from '@/types';
+import { SchemaMachineContext } from '../schemaMachine';
+export declare const validateSchema: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<SchemaMachineContext>, EventObject>;
+//# sourceMappingURL=validateSchema.d.ts.map

package/dist/src/Schema/service/actors/validateSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateSchema.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/validateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAQvD,eAAO,MAAM,cAAc,wGA8DzB,CAAA"}

package/dist/src/Schema/service/actors/verifyModelInstancesInCache.d.ts

@@ -0,0 +1,6 @@
+import { EventObject } from 'xstate';
+export type VerifyModelInstancesInCacheInput = {
+    modelIds: string[];
+};
+export declare const verifyModelInstancesInCache: import("xstate").CallbackActorLogic<EventObject, VerifyModelInstancesInCacheInput, EventObject>;
+//# sourceMappingURL=verifyModelInstancesInCache.d.ts.map

package/dist/src/Schema/service/actors/verifyModelInstancesInCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyModelInstancesInCache.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/verifyModelInstancesInCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAKlD,MAAM,MAAM,gCAAgC,GAAG;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AA6BD,eAAO,MAAM,2BAA2B,iGAuEtC,CAAA"}

package/dist/src/Schema/service/actors/verifyModelsInDb.d.ts

@@ -0,0 +1,7 @@
+import { EventObject } from 'xstate';
+export type VerifyModelsInDbInput = {
+    schemaId: number;
+    expectedModelIds?: string[];
+};
+export declare const verifyModelsInDb: import("xstate").CallbackActorLogic<EventObject, VerifyModelsInDbInput, EventObject>;
+//# sourceMappingURL=verifyModelsInDb.d.ts.map

package/dist/src/Schema/service/actors/verifyModelsInDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyModelsInDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/verifyModelsInDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAQlD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AA6BD,eAAO,MAAM,gBAAgB,sFA+E3B,CAAA"}

package/dist/src/Schema/service/actors/verifyPropertiesInDb.d.ts

@@ -0,0 +1,8 @@
+import { EventObject } from 'xstate';
+export type VerifyPropertiesInDbInput = {
+    modelIds?: number[];
+    modelFileIds?: string[];
+    expectedPropertyIds?: string[];
+};
+export declare const verifyPropertiesInDb: import("xstate").CallbackActorLogic<EventObject, VerifyPropertiesInDbInput, EventObject>;
+//# sourceMappingURL=verifyPropertiesInDb.d.ts.map

package/dist/src/Schema/service/actors/verifyPropertiesInDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyPropertiesInDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/verifyPropertiesInDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAQlD,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC/B,CAAA;AA6BD,eAAO,MAAM,oBAAoB,0FA4G/B,CAAA"}

package/dist/src/Schema/service/actors/verifyPropertyInstancesInCache.d.ts

@@ -0,0 +1,6 @@
+import { EventObject } from 'xstate';
+export type VerifyPropertyInstancesInCacheInput = {
+    propertyIds: string[];
+};
+export declare const verifyPropertyInstancesInCache: import("xstate").CallbackActorLogic<EventObject, VerifyPropertyInstancesInCacheInput, EventObject>;
+//# sourceMappingURL=verifyPropertyInstancesInCache.d.ts.map