@seedprotocol/sdk 0.7.5 → 0.7.6

package/dist/dist/Schema-DppObO6h.d.ts

@@ -0,0 +1,601 @@
+declare class Schema {
+    static create(schemaName: any, options: any): any;
+    /**
+     * 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
+     */
+    static _updateCacheKey(schemaName: any, schemaFileId: any): void;
+    /**
+     * Get schema instance by schemaFileId (preferred method)
+     * Returns null if not found in cache
+     */
+    static getById(schemaFileId: any): any;
+    /**
+     * 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: any): Promise<any>;
+    /**
+     * Find schema instance by schemaFileId
+     * Waits for the schema to be fully loaded (idle state) by default
+     * @param options - Find options including schemaFileId and wait configuration
+     * @returns Schema instance if found, undefined otherwise
+     */
+    static find({ schemaFileId, waitForReady, readyTimeout, }: {
+        schemaFileId: any;
+        waitForReady?: boolean | undefined;
+        readyTimeout?: number | undefined;
+    }): Promise<any>;
+    /**
+     * 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?: {}): Promise<any[]>;
+    /**
+     * Force-evict the cached Schema instance(s) named `schemaName`, ignoring refCounts: stop their live
+     * query and service. Schema.destroy does the same for itself. For code that deletes a schema's rows
+     * without destroying it (test cleanup): a live Schema keeps re-creating its models from its live
+     * query while their rows are being deleted.
+     */
+    static evict(schemaName: any): void;
+    constructor(schemaName: 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: "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: "loadOrCreateSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "checkExistingSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeSchemaToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifySchemaInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyModelsInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createModelInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyModelInstancesInCache";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writePropertiesToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyPropertiesInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createPropertyInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyPropertyInstancesInCache";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, "error" | "idle" | "validating" | {
+        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+    }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "schema";
+        states: {
+            readonly loading: {
+                states: {
+                    readonly checkingExisting: {};
+                    readonly writingSchema: {};
+                    readonly verifyingSchema: {};
+                    readonly writingModels: {};
+                    readonly verifyingModels: {};
+                    readonly creatingModelInstances: {};
+                    readonly verifyingModelInstances: {};
+                    readonly writingProperties: {};
+                    readonly verifyingProperties: {};
+                    readonly creatingPropertyInstances: {};
+                    readonly verifyingPropertyInstances: {};
+                };
+            };
+            readonly idle: {};
+            readonly validating: {};
+            readonly error: {};
+        };
+    }, 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: "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: "loadOrCreateSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "checkExistingSchema";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeSchemaToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifySchemaInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writeModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyModelsInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createModelInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyModelInstancesInCache";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "writePropertiesToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyPropertiesInDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "createPropertyInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "verifyPropertyInstancesInCache";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, "error" | "idle" | "validating" | {
+        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+    }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "schema";
+        states: {
+            readonly loading: {
+                states: {
+                    readonly checkingExisting: {};
+                    readonly writingSchema: {};
+                    readonly verifyingSchema: {};
+                    readonly writingModels: {};
+                    readonly verifyingModels: {};
+                    readonly creatingModelInstances: {};
+                    readonly verifyingModelInstances: {};
+                    readonly writingProperties: {};
+                    readonly verifyingProperties: {};
+                    readonly creatingPropertyInstances: {};
+                    readonly verifyingPropertyInstances: {};
+                };
+            };
+            readonly idle: {};
+            readonly validating: {};
+            readonly error: {};
+        };
+    }, 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;
+    }, "error" | "idle" | "validating" | {
+        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+    }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
+        id: "schema";
+        states: {
+            readonly loading: {
+                states: {
+                    readonly checkingExisting: {};
+                    readonly writingSchema: {};
+                    readonly verifyingSchema: {};
+                    readonly writingModels: {};
+                    readonly verifyingModels: {};
+                    readonly creatingModelInstances: {};
+                    readonly verifyingModelInstances: {};
+                    readonly writingProperties: {};
+                    readonly verifyingProperties: {};
+                    readonly creatingPropertyInstances: {};
+                    readonly verifyingPropertyInstances: {};
+                };
+            };
+            readonly idle: {};
+            readonly validating: {};
+            readonly error: {};
+        };
+    }>;
+    _getSnapshotContext(): {};
+    get schemaName(): any;
+    get schemaFileId(): any;
+    get id(): any;
+    /**
+     * Returns Model instances for this schema
+     * This is a computed property that reads from the service context
+     * Note: This is NOT reactive - use useModels() hook for reactivity
+     */
+    get models(): any[];
+    get status(): "error" | "idle" | "validating" | {
+        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+    };
+    get isEdited(): any;
+    get validationErrors(): any;
+    /**
+     * The error from the last draft save that an assignment started (e.g. `schema.name = ...`),
+     * such as a ConflictError; undefined once a later one succeeds.
+     */
+    get lastSaveError(): any;
+    get isValid(): boolean;
+    /**
+     * Validate the schema
+     * @returns Validation result
+     */
+    validate(): Promise<any>;
+    /**
+     * Build the file-format `models` object from this schema's Model instances: every model
+     * (those created at runtime too), each property as its file definition ({ id, type, model,
+     * ref, refValueType, required, storage, validation, ... }).
+     */
+    _buildModelsFromInstances(): Promise<{}>;
+    /**
+     * 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<any>;
+    /**
+     * Check for conflicts between actor context and database
+     * @returns ConflictResult indicating if a conflict exists
+     */
+    _checkForConflicts(): Promise<{
+        hasConflict: boolean;
+        localVersion?: undefined;
+        dbVersion?: undefined;
+        localUpdatedAt?: undefined;
+        dbUpdatedAt?: undefined;
+        message?: undefined;
+    } | {
+        hasConflict: boolean;
+        localVersion: any;
+        dbVersion: any;
+        localUpdatedAt: any;
+        dbUpdatedAt: string;
+        message: string;
+    }>;
+    /**
+     * Reload schema from database
+     * This refreshes the actor context with the latest data from the database
+     */
+    reload(): Promise<any>;
+    /**
+     * 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)
+     */
+    _saveDraftToDb(oldName: any, newName: any): Promise<void>;
+    unload(): void;
+    /**
+     * Destroy the schema instance completely: remove from caches, delete from database (cascade),
+     * and stop the service. Uses shared destroy helpers.
+     */
+    destroy(): Promise<void>;
+    _destroyRows(schemaFileId: any, schemaName: any, metadataName: any): Promise<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)
+     */
+    _setupLiveQuerySubscription(): void;
+}
+declare namespace Schema {
+    let instanceCacheById: Map<any, any>;
+    let instanceCacheByName: Map<any, any>;
+    let pendingSchemaByName: Map<any, any>;
+    let savingSchemas: Set<any>;
+}
+/**
+ * Delete a property from a model in a schema
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model
+ * @param propertyName - The name of the property to delete
+ * @param options - Optional deletion options
+ * @returns The file path of the new schema version
+ * @throws Error if schema, model, or property not found
+ */
+declare function deletePropertyFromModel(schemaName: any, modelName: any, propertyName: any, options?: {}): Promise<any>;
+declare var Schema$1: Readonly<{
+    __proto__: null;
+    Schema: typeof Schema;
+    schemaInstanceState: WeakMap<object, any>;
+}>;
+/**
+ * Delete a model from a schema
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model to delete
+ * @param options - Optional deletion options
+ * @returns The file path of the new schema version
+ * @throws Error if schema or model not found
+ */
+declare function deleteModelFromSchema(schemaName: any, modelName: any, options?: {}): Promise<any>;
+/**
+ * Rename a property in a model
+ * This is a convenience function that updates the property name
+ * Note: This creates a new property and you may want to handle the old property separately
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model
+ * @param oldPropertyName - The current property name
+ * @param newPropertyName - The new property name
+ * @returns The file path of the new schema version
+ */
+declare function renameModelProperty(schemaName: any, modelName: any, oldPropertyName: any, newPropertyName: any): Promise<any>;
+declare const schemaMachine: 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: "loadOrCreateSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "checkExistingSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeSchemaToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifySchemaInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeModelsToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyModelsInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createModelInstances";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyModelInstancesInCache";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writePropertiesToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyPropertiesInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createPropertyInstances";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyPropertyInstancesInCache";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, never, never, "error" | "idle" | "validating" | {
+    loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "schema";
+    states: {
+        readonly loading: {
+            states: {
+                readonly checkingExisting: {};
+                readonly writingSchema: {};
+                readonly verifyingSchema: {};
+                readonly writingModels: {};
+                readonly verifyingModels: {};
+                readonly creatingModelInstances: {};
+                readonly verifyingModelInstances: {};
+                readonly writingProperties: {};
+                readonly verifyingProperties: {};
+                readonly creatingPropertyInstances: {};
+                readonly verifyingPropertyInstances: {};
+            };
+        };
+        readonly idle: {};
+        readonly validating: {};
+        readonly error: {};
+    };
+}, import("xstate").MetaObject>;
+/**
+ * Update model properties in a schema and create a new version
+ * @param schemaName - The name of the schema to update
+ * @param propertyUpdates - Array of property updates to apply
+ * @param modelUpdates - Optional array of model renames
+ * @returns The file path of the new schema version
+ * @throws Error if schema not found or updates are invalid
+ */
+declare function updateModelProperties(schemaName: any, propertyUpdates: any, modelUpdates: any): Promise<any>;
+export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
+//# sourceMappingURL=Schema-DppObO6h.d.ts.map

package/dist/dist/Schema-DppObO6h.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema-DppObO6h.d.ts","sourceRoot":"","sources":["../Schema-DppObO6h.js"],"names":[],"mappings":"AAihIA;IAiCI,kDAoPC;IACD;;;;OAIG;IACH,iEAgBC;IACD;;;OAGG;IACH,uCAUC;IACD;;;;OAIG;IACH,0BAwBC;IACD;;;;;OAKG;IACH,mDA8BC;IACD;;;;;OAKG;IACH;;;;qBAgBC;IACD;;;;;;;;;OASG;IACH,yCA8IC;IA21BD;;;;;OAKG;IACH,oCAkCC;IA/6CD,6BA+BC;IA3BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAuiBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,sBAeC;IACD,wBAEC;IACD,cAEC;IACD;;;;OAIG;IACH,oBAmCC;IACD;;MAEC;IACD,oBAcC;IACD,4BAEC;IACD;;;OAGG;IACH,yBAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD;;;;OAIG;IACH,yCAoEC;IACD;;;;;;OAMG;IACH,+BAsLC;IACD;;;OAGG;IACH;;;;;;;;;;;;;;OAyCC;IACD;;;OAGG;IACH,uBAwBC;IACD;;;;;OAKG;IACH,0DAqXC;IA0CD,eAsCC;IACD;;;OAGG;IACH,yBAgCC;IACD,mFAqEC;IACD;;;OAGG;IACH,oCAgKC;CACJ;;;;;;;AAh2DD;;;;;;;;GAQG;AACH,yHA4EC;AAqxDD;;;;GAIG;AA1/DH;;;;;;;GAOG;AACH,oGAmIC;AA5PD;;;;;;;;;GASG;AACH,gIAsGC;AAvlCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4jBG;AA2LH;;;;;;;GAOG;AACH,+GA6HC"}