@seedprotocol/sdk 0.3.31 → 0.4.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifyPropertyInstancesInCache.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/verifyPropertyInstancesInCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAKlD,MAAM,MAAM,mCAAmC,GAAG;IAChD,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AA6BD,eAAO,MAAM,8BAA8B,oGAuEzC,CAAA"}

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

@@ -0,0 +1,7 @@
+import { EventObject } from 'xstate';
+export type VerifySchemaInDbInput = {
+    schemaFileId: string;
+    expectedSchemaId?: number;
+};
+export declare const verifySchemaInDb: import("xstate").CallbackActorLogic<EventObject, VerifySchemaInDbInput, EventObject>;
+//# sourceMappingURL=verifySchemaInDb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifySchemaInDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/verifySchemaInDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAQlD,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AA+BD,eAAO,MAAM,gBAAgB,sFAgE3B,CAAA"}

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

@@ -0,0 +1,9 @@
+import { EventObject } from 'xstate';
+import { SchemaFileFormat } from '@/types/import';
+export type WriteModelsToDbInput = {
+    schema: SchemaFileFormat;
+    schemaRecord: any;
+    schemaName: string;
+};
+export declare const writeModelsToDb: import("xstate").CallbackActorLogic<EventObject, WriteModelsToDbInput, EventObject>;
+//# sourceMappingURL=writeModelsToDb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeModelsToDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/writeModelsToDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAyB,MAAM,gBAAgB,CAAA;AAOxE,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,gBAAgB,CAAA;IACxB,YAAY,EAAE,GAAG,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,eAAe,qFAgN1B,CAAA"}

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

@@ -0,0 +1,10 @@
+import { EventObject } from 'xstate';
+export type WritePropertiesToDbInput = {
+    modelIds: string[];
+};
+/**
+ * Properties are typically written to DB as part of writeModelsToDb
+ * This actor verifies that properties exist and extracts their IDs
+ */
+export declare const writePropertiesToDb: import("xstate").CallbackActorLogic<EventObject, WritePropertiesToDbInput, EventObject>;
+//# sourceMappingURL=writePropertiesToDb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writePropertiesToDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/writePropertiesToDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAKlD,MAAM,MAAM,wBAAwB,GAAG;IAIrC,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,yFAqE9B,CAAA"}

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

@@ -0,0 +1,11 @@
+import { EventObject } from 'xstate';
+import { SchemaFileFormat } from '@/types/import';
+export type WriteSchemaToDbInput = {
+    schemaName: string;
+    schemaFile?: SchemaFileFormat;
+    existingDbSchema?: {
+        version?: number;
+    };
+};
+export declare const writeSchemaToDb: import("xstate").CallbackActorLogic<EventObject, WriteSchemaToDbInput, EventObject>;
+//# sourceMappingURL=writeSchemaToDb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeSchemaToDb.d.ts","sourceRoot":"","sources":["../../../../../src/Schema/service/actors/writeSchemaToDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAyB,MAAM,gBAAgB,CAAA;AAWxE,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,gBAAgB,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe,qFAoJ1B,CAAA"}

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

@@ -0,0 +1,111 @@
+import type { EventObject } from 'xstate';
+import { SchemaMachineContext } from './schemaMachine';
+import { Model } from '@/Model/Model';
+export type AddModelsMachineContext = {
+    schemaContext: SchemaMachineContext;
+    models: {
+        [modelName: string]: any;
+    };
+    existingModels: {
+        [modelName: string]: any;
+    };
+    modelInstances?: Map<string, Model>;
+    modelFileIds?: Map<string, string>;
+    errors?: Array<{
+        modelName: string;
+        error: Error;
+    }>;
+    progress?: {
+        stage: 'preparing' | 'creatingInstances' | 'collectingIds' | 'persisting';
+        currentModel?: string;
+        totalModels: number;
+        completedModels: number;
+    };
+};
+export declare const addModelsMachine: import("xstate").StateMachine<AddModelsMachineContext, {
+    type: "validateModels";
+} | {
+    type: "createModelInstances";
+} | {
+    type: "collectModelFileIds";
+} | {
+    type: "persistModelsToDb";
+} | {
+    type: "progress";
+    stage: "preparing" | "creatingInstances" | "collectingIds" | "persisting";
+    currentModel?: string;
+} | {
+    type: "error";
+    error: Error;
+    modelName?: string;
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+    }, EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, {
+        newModels: {
+            [modelName: string]: any;
+        };
+        existingModels: {
+            [modelName: string]: any;
+        };
+    }, EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, {
+        modelInstances: Map<string, Model>;
+    }, EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+        modelFileIds: Map<string, string>;
+    }, EventObject>> | undefined;
+}, {
+    src: "createModelInstances";
+    logic: import("xstate").CallbackActorLogic<EventObject, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+    }, EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateModels";
+    logic: import("xstate").CallbackActorLogic<EventObject, {
+        newModels: {
+            [modelName: string]: any;
+        };
+        existingModels: {
+            [modelName: string]: any;
+        };
+    }, EventObject>;
+    id: string | undefined;
+} | {
+    src: "collectModelFileIds";
+    logic: import("xstate").CallbackActorLogic<EventObject, {
+        modelInstances: Map<string, Model>;
+    }, EventObject>;
+    id: string | undefined;
+} | {
+    src: "persistModelsToDb";
+    logic: import("xstate").CallbackActorLogic<EventObject, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+        modelFileIds: Map<string, string>;
+    }, EventObject>;
+    id: string | undefined;
+}, never, never, never, {}, string, {
+    schemaContext: SchemaMachineContext;
+    models: {
+        [modelName: string]: any;
+    };
+    existingModels: {
+        [modelName: string]: any;
+    };
+}, import("xstate").NonReducibleUnknown, EventObject, import("xstate").MetaObject, {
+    id?: string | undefined | undefined;
+    states?: {} | undefined;
+}>;
+//# sourceMappingURL=addModelsMachine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addModelsMachine.d.ts","sourceRoot":"","sources":["../../../../src/Schema/service/addModelsMachine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAErC,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,oBAAoB,CAAA;IACnC,MAAM,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IACpC,cAAc,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IAC5C,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACnC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAA;IACnD,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,WAAW,GAAG,mBAAmB,GAAG,eAAe,GAAG,YAAY,CAAA;QACzE,YAAY,CAAC,EAAE,MAAM,CAAA;QACrB,WAAW,EAAE,MAAM,CAAA;QACnB,eAAe,EAAE,MAAM,CAAA;KACxB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,gBAAgB;UASb,gBAAgB;;UAChB,sBAAsB;;UACtB,qBAAqB;;UACrB,mBAAmB;;UACnB,UAAU;WAAS,WAAW,GAAG,mBAAmB,GAAG,eAAe,GAAG,YAAY;mBAAiB,MAAM;;UAC5G,OAAO;WAAS,KAAK;gBAAc,MAAM;;;uBAkDlC,oBAAoB;gBAAU;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;;mBA7C9D;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;wBAAkB;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;;wBA6NrE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;;uBAsEnB,oBAAoB;gBAC3B;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;sBACtB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;uBAxPlB,oBAAoB;gBAAU;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;;;;;;mBA7C9D;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;wBAAkB;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;;;;;;wBA6NrE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;;;;;;uBAsEnB,oBAAoB;gBAC3B;YAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE;sBACtB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;;;;mBApTpB,oBAAoB;YAC3B;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;oBACpB;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;;;;EA8lBhD,CAAA"}

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

@@ -0,0 +1,494 @@
+import { ActorRefFrom } from 'xstate';
+import { SchemaFileFormat } from '@/types/import';
+import { ValidationError } from '@/Schema/validation';
+import { writeProcessMachine } from '@/services/write/writeProcessMachine';
+export type SchemaMachineContext = {
+    schemaName: string;
+    $schema?: string;
+    version?: number;
+    metadata?: {
+        name: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    models?: {
+        [modelName: string]: {
+            properties: {
+                [propertyName: string]: any;
+            };
+        };
+    };
+    enums?: {
+        [enumName: string]: any;
+    };
+    migrations?: Array<{
+        version: number;
+        timestamp: string;
+        description: string;
+        changes: any[];
+    }>;
+    _isDraft?: boolean;
+    _isEdited?: boolean;
+    _editedProperties?: Set<string>;
+    _validationErrors?: ValidationError[];
+    id?: string;
+    _dbId?: number;
+    _loadedAt?: number;
+    _dbVersion?: number;
+    _dbUpdatedAt?: number;
+    _pendingModelAdditions?: Array<{
+        models: {
+            [modelName: string]: any;
+        };
+        timestamp: number;
+    }>;
+    _modelAdditionErrors?: Array<{
+        error: Error;
+        timestamp: number;
+    }>;
+    writeProcess?: ActorRefFrom<typeof writeProcessMachine> | null;
+    _liveQueryModelIds?: string[];
+    _modelIds?: string[];
+    _propertyIds?: string[];
+    _loadingStage?: string;
+    _loadingError?: {
+        stage: string;
+        error: Error;
+    };
+    _schemaRecord?: any;
+};
+export declare const schemaMachine: import("xstate").StateMachine<SchemaMachineContext, {
+    [key: string]: any;
+    type: "updateContext";
+} | {
+    type: "loadOrCreateSchema";
+} | {
+    type: "loadOrCreateSchemaSuccess";
+    schema: SchemaFileFormat;
+} | {
+    type: "loadOrCreateSchemaError";
+    error: Error;
+} | {
+    type: "markAsDraft";
+    propertyKey: string;
+} | {
+    type: "clearDraft";
+    _dbUpdatedAt?: number;
+    _dbVersion?: number;
+} | {
+    type: "validateSchema";
+} | {
+    type: "validationSuccess";
+    errors: ValidationError[];
+} | {
+    type: "validationError";
+    errors: ValidationError[];
+} | {
+    type: "reloadFromDb";
+} | {
+    type: "addModels";
+    models: {
+        [modelName: string]: any;
+    };
+} | {
+    type: "requestWrite";
+    data: any;
+} | {
+    type: "schemaFound";
+    schema: SchemaFileFormat;
+    schemaRecord: any;
+    modelIds?: string[];
+    loadedAt?: number;
+    dbVersion?: number;
+    dbUpdatedAt?: number;
+} | {
+    type: "schemaNotFound";
+} | {
+    type: "schemaWritten";
+    schemaRecord: any;
+    schema: SchemaFileFormat;
+} | {
+    type: "schemaVerified";
+    schemaId: number;
+} | {
+    type: "modelsWritten";
+    modelIds: string[];
+} | {
+    type: "modelsVerified";
+    modelIds: string[];
+} | {
+    type: "instancesCreated";
+    count: number;
+} | {
+    type: "instancesVerified";
+    count: number;
+} | {
+    type: "propertiesWritten";
+    propertyIds: string[];
+} | {
+    type: "propertiesVerified";
+    propertyIds: string[];
+} | {
+    type: "verificationFailed";
+    stage: string;
+    error: Error;
+} | {
+    type: "writeError";
+    error: Error;
+}, {
+    [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<SchemaMachineContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").StateMachine<import("./addModelsMachine").AddModelsMachineContext, {
+        type: "validateModels";
+    } | {
+        type: "createModelInstances";
+    } | {
+        type: "collectModelFileIds";
+    } | {
+        type: "persistModelsToDb";
+    } | {
+        type: "progress";
+        stage: "preparing" | "creatingInstances" | "collectingIds" | "persisting";
+        currentModel?: string;
+    } | {
+        type: "error";
+        error: Error;
+        modelName?: string;
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            newModels: {
+                [modelName: string]: any;
+            };
+            existingModels: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            modelInstances: Map<string, import("..").Model>;
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+            modelFileIds: Map<string, string>;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "createModelInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateModels";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            newModels: {
+                [modelName: string]: any;
+            };
+            existingModels: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "collectModelFileIds";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            modelInstances: Map<string, import("..").Model>;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "persistModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+            modelFileIds: Map<string, string>;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+        existingModels: {
+            [modelName: string]: any;
+        };
+    }, 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("./actors/writeSchemaToDb").WriteSchemaToDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifySchemaInDb").VerifySchemaInDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/writeModelsToDb").WriteModelsToDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyModelsInDb").VerifyModelsInDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/createModelInstances").CreateModelInstancesInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyModelInstancesInCache").VerifyModelInstancesInCacheInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/writePropertiesToDb").WritePropertiesToDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyPropertiesInDb").VerifyPropertiesInDbInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/createPropertyInstances").CreatePropertyInstancesInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyPropertyInstancesInCache").VerifyPropertyInstancesInCacheInput, import("xstate").EventObject>> | 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;
+} | {
+    src: "loadOrCreateSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<SchemaMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<SchemaMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "addModelsMachine";
+    logic: import("xstate").StateMachine<import("./addModelsMachine").AddModelsMachineContext, {
+        type: "validateModels";
+    } | {
+        type: "createModelInstances";
+    } | {
+        type: "collectModelFileIds";
+    } | {
+        type: "persistModelsToDb";
+    } | {
+        type: "progress";
+        stage: "preparing" | "creatingInstances" | "collectingIds" | "persisting";
+        currentModel?: string;
+    } | {
+        type: "error";
+        error: Error;
+        modelName?: string;
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            newModels: {
+                [modelName: string]: any;
+            };
+            existingModels: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            modelInstances: Map<string, import("..").Model>;
+        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+            modelFileIds: Map<string, string>;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "createModelInstances";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "validateModels";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            newModels: {
+                [modelName: string]: any;
+            };
+            existingModels: {
+                [modelName: string]: any;
+            };
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "collectModelFileIds";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            modelInstances: Map<string, import("..").Model>;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "persistModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            schemaContext: SchemaMachineContext;
+            models: {
+                [modelName: string]: any;
+            };
+            modelFileIds: Map<string, string>;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, {}, string, {
+        schemaContext: SchemaMachineContext;
+        models: {
+            [modelName: string]: any;
+        };
+        existingModels: {
+            [modelName: string]: any;
+        };
+    }, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id?: string | undefined | undefined;
+        states?: {} | undefined;
+    }>;
+    id: string | undefined;
+} | {
+    src: "checkExistingSchema";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<SchemaMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeSchemaToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/writeSchemaToDb").WriteSchemaToDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifySchemaInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifySchemaInDb").VerifySchemaInDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writeModelsToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/writeModelsToDb").WriteModelsToDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyModelsInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyModelsInDb").VerifyModelsInDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createModelInstances";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/createModelInstances").CreateModelInstancesInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyModelInstancesInCache";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyModelInstancesInCache").VerifyModelInstancesInCacheInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "writePropertiesToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/writePropertiesToDb").WritePropertiesToDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyPropertiesInDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyPropertiesInDb").VerifyPropertiesInDbInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createPropertyInstances";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/createPropertyInstances").CreatePropertyInstancesInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "verifyPropertyInstancesInCache";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("./actors/verifyPropertyInstancesInCache").VerifyPropertyInstancesInCacheInput, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "hasValidationErrors";
+    params: unknown;
+} | {
+    type: "isSchemaValid";
+    params: unknown;
+}, never, "idle" | "error" | "validating" | "addingModels" | {
+    loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
+}, string, Pick<SchemaMachineContext, "schemaName">, 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 addingModels: {};
+        readonly validating: {};
+        readonly error: {};
+    };
+}>;
+//# sourceMappingURL=schemaMachine.d.ts.map