@seedprotocol/sdk 0.4.2 → 0.4.3

package/dist/Model/service/modelMachine.d.ts

@@ -0,0 +1,207 @@
+import { ActorRefFrom } from 'xstate';
+import { ValidationError } from '@/Schema/validation';
+import { writeProcessMachine } from '@/services/write/writeProcessMachine';
+export type ModelMachineContext = {
+    id?: string;
+    _dbId?: number;
+    modelName: string;
+    schemaName: string;
+    _isEdited?: boolean;
+    _editedProperties?: Set<string>;
+    _validationErrors?: ValidationError[];
+    _originalValues?: {
+        properties?: {
+            [propertyName: string]: any;
+        };
+    };
+    writeProcess?: ActorRefFrom<typeof writeProcessMachine> | null;
+    _liveQueryPropertyIds?: string[];
+    _pendingPropertyDefinitions?: {
+        [propertyName: string]: any;
+    };
+    _modelFileId?: string;
+    _loadedAt?: number;
+    _dbVersion?: number;
+    _dbUpdatedAt?: number;
+};
+export declare const modelMachine: import("xstate").StateMachine<ModelMachineContext, {
+    [key: string]: any;
+    type: "updateContext";
+} | {
+    type: "loadOrCreateModel";
+} | {
+    type: "loadOrCreateModelSuccess";
+    model: Omit<ModelMachineContext, "modelName" | "schemaName" | "_isEdited" | "_editedProperties" | "_validationErrors" | "_loadedAt" | "_dbVersion" | "_dbUpdatedAt"> & Partial<Pick<ModelMachineContext, "_loadedAt" | "_dbVersion" | "_dbUpdatedAt">>;
+} | {
+    type: "loadOrCreateModelError";
+    error: Error;
+} | {
+    type: "initializeOriginalValues";
+    originalValues: Partial<ModelMachineContext>;
+    isEdited?: boolean;
+} | {
+    type: "markAsDraft";
+    propertyKey: string;
+} | {
+    type: "clearDraft";
+} | {
+    type: "validateModel";
+} | {
+    type: "validationSuccess";
+    errors: ValidationError[];
+} | {
+    type: "validationError";
+    errors: ValidationError[];
+} | {
+    type: "reloadFromDb";
+} | {
+    type: "requestWrite";
+    data: any;
+} | {
+    type: "writeSuccess";
+    output: any;
+} | {
+    type: "createModelPropertiesSuccess";
+} | {
+    type: "createModelPropertiesError";
+    error: Error;
+} | {
+    type: "refreshProperties";
+}, {
+    [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<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: any;
+        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, "error" | "idle" | "validating" | "writing" | "success", string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "writeProcess";
+        states: {
+            readonly idle: {};
+            readonly validating: {};
+            readonly writing: {};
+            readonly success: {};
+            readonly error: {};
+        };
+    }>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext> & {
+        propertyDefinitions: {
+            [name: string]: any;
+        };
+    }, 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<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: any;
+        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, "error" | "idle" | "validating" | "writing" | "success", string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "writeProcess";
+        states: {
+            readonly idle: {};
+            readonly validating: {};
+            readonly writing: {};
+            readonly success: {};
+            readonly error: {};
+        };
+    }>;
+    id: string | undefined;
+} | {
+    src: "loadOrCreateModel";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "validateModel";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "createModelProperties";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("../..").FromCallbackInput<ModelMachineContext> & {
+        propertyDefinitions: {
+            [name: string]: any;
+        };
+    }, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "assignValidationErrors";
+    params: import("xstate").NonReducibleUnknown;
+}, {
+    type: "hasValidationErrors";
+    params: unknown;
+} | {
+    type: "isModelValid";
+    params: unknown;
+}, never, "error" | "idle" | "validating" | "loading" | "creatingProperties", string, Pick<ModelMachineContext, "id" | "modelName" | "schemaName" | "_pendingPropertyDefinitions">, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "model";
+    states: {
+        readonly loading: {};
+        readonly idle: {};
+        readonly validating: {};
+        readonly creatingProperties: {};
+        readonly error: {};
+    };
+}>;
+//# sourceMappingURL=modelMachine.d.ts.map

package/dist/Model/service/modelMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelMachine.d.ts","sourceRoot":"","sources":["../../../src/Model/service/modelMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,YAAY,EAAE,MAAM,QAAQ,CAAA;AAIpD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAA;AAK1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAA;IAErC,eAAe,CAAC,EAAE;QAChB,UAAU,CAAC,EAAE;YAAE,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAA;KAC7C,CAAA;IACD,YAAY,CAAC,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAC9D,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAA;IAChC,2BAA2B,CAAC,EAAE;QAAE,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,YAAY;;UAKT,eAAe;;UACf,mBAAmB;;UACnB,0BAA0B;WAAS,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,mBAAmB,GAAG,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC,CAAC;;UAClR,wBAAwB;WAAS,KAAK;;UACtC,0BAA0B;oBAAkB,OAAO,CAAC,mBAAmB,CAAC;eAAa,OAAO;;UAC5F,aAAa;iBAAe,MAAM;;UAClC,YAAY;;UACZ,eAAe;;UACf,mBAAmB;YAAU,eAAe,EAAE;;UAC9C,iBAAiB;YAAU,eAAe,EAAE;;UAC5C,cAAc;;UACd,cAAc;UAAQ,GAAG;;UACzB,cAAc;YAAU,GAAG;;UAC3B,8BAA8B;;UAC9B,4BAA4B;WAAS,KAAK;;UAC1C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiYjC,CAAA"}

package/dist/ModelProperty/ModelProperty.d.ts

@@ -0,0 +1,123 @@
+import { ActorRefFrom } from 'xstate';
+import { Static } from '@sinclair/typebox';
+import { ModelPropertyDataTypes, TProperty } from '@/Schema';
+import { modelPropertyMachine, ModelPropertyMachineContext } 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>;
+    /**
+     * Find ModelProperty instance by propertyFileId
+     * Waits for the property to be fully loaded (idle state) by default
+     * @param options - Find options including propertyFileId and wait configuration
+     * @returns ModelProperty instance if found, undefined otherwise
+     */
+    static find({ propertyFileId, waitForReady, readyTimeout, }: {
+        propertyFileId: string;
+        waitForReady?: boolean;
+        readyTimeout?: number;
+    }): 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;
+    _getSnapshotContext(): ModelPropertyMachineContext;
+    get path(): string | undefined;
+    get status(): "compareAndMarkDraft" | "idle" | "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/ModelProperty/ModelProperty.d.ts.map

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

package/dist/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,+GAmK9B,CAAA"}

package/dist/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/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/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<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: any;
+        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, "error" | "idle" | "validating" | "writing" | "success", string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "writeProcess";
+        states: {
+            readonly idle: {};
+            readonly validating: {};
+            readonly writing: {};
+            readonly success: {};
+            readonly error: {};
+        };
+    }>> | 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<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            entityType: "model" | "modelProperty" | "schema";
+            entityId: string;
+            entityData: any;
+        }, import("xstate").EventObject>> | undefined;
+    }, {
+        src: "validateEntity";
+        logic: any;
+        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, "error" | "idle" | "validating" | "writing" | "success", string, Partial<import("@/services/write/writeProcessMachine").WriteProcessContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: "writeProcess";
+        states: {
+            readonly idle: {};
+            readonly validating: {};
+            readonly writing: {};
+            readonly success: {};
+            readonly error: {};
+        };
+    }>;
+    id: string | undefined;
+}, {
+    type: "assignValidationErrors";
+    params: import("xstate").NonReducibleUnknown;
+}, {
+    type: "isPropertyValid";
+    params: unknown;
+} | {
+    type: "hasValidationErrors";
+    params: unknown;
+}, never, "compareAndMarkDraft" | "idle" | "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/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,EAAiB,YAAY,EAAE,MAAM,QAAQ,CAAA;AACpD,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"}