@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/src/browser/react/model.d.ts

@@ -1,7 +1,34 @@
-import { ModelClassType } from '@/types';
-export declare const useModels: () => {
-    models: {
-        [key: string]: ModelClassType;
-    } | undefined;
+import { Model } from '@/Model/Model';
+type UseModelsResult = {
+    models: Model[];
+    isLoading: boolean;
+    error: Error | null;
 };
+type UseModelsParams = string | null | undefined;
+type UseModels = (schemaId: UseModelsParams) => UseModelsResult;
+/**
+ * Hook to get all Model instances for a specific schema
+ * Uses useLiveQuery to watch for changes in the models table and automatically
+ * updates the returned Model instances when changes occur.
+ * @param schemaId - The schema ID (schema file ID) or schema name to get models from
+ * @returns Array of Model instances belonging to the schema
+ */
+export declare const useModels: UseModels;
+type UseModelResult = {
+    model: Model | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to get a specific Model instance
+ * Can be called in two ways:
+ * 1. With schemaId and modelName: useModel(schemaId, modelName)
+ * 2. With modelId: useModel(modelId)
+ *
+ * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
+ * @param modelName - The name of the model to retrieve (required if first param is schemaId)
+ * @returns Object with model, isLoading, and error
+ */
+export declare const useModel: (schemaIdOrModelId: string | null | undefined, modelName?: string | null | undefined) => UseModelResult;
+export {};
 //# sourceMappingURL=model.d.ts.map

package/dist/src/browser/react/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/model.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAExC,eAAO,MAAM,SAAS;;;;CAgBrB,CAAA"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/model.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAUrC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA;AAED,KAAK,eAAe,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;AAEhD,KAAK,SAAS,GAAG,CAAC,QAAQ,EAAE,eAAe,KAAK,eAAe,CAAA;AAE/D;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,SAoJvB,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAA;IACxB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GACnB,mBAAmB,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,YAAY,MAAM,GAAG,IAAI,GAAG,SAAS,KACpC,cAmIF,CAAA"}

package/dist/src/browser/react/modelProperty.d.ts

@@ -0,0 +1,59 @@
+import { ModelProperty } from "@/ModelProperty/ModelProperty";
+type UseModelPropertiesResult = {
+    modelProperties: ModelProperty[];
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to get all ModelProperty instances for a specific model
+ * Can be called in two ways:
+ * 1. With schemaId and modelName: useModelProperties(schemaId, modelName)
+ * 2. With modelId: useModelProperties(modelId)
+ *
+ * Uses useLiveQuery to watch for changes in the properties table and automatically
+ * updates the returned ModelProperty instances when changes occur.
+ *
+ * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
+ * @param modelName - The name of the model to get properties from (required if first param is schemaId)
+ * @returns Object with modelProperties array, isLoading, and error
+ */
+export declare const useModelProperties: (schemaIdOrModelId: string | null | undefined, modelName?: string | null | undefined) => UseModelPropertiesResult;
+/**
+ * Hook to get a specific ModelProperty instance
+ * Can be called in three ways:
+ * 1. With propertyFileId: useModelProperty(propertyFileId)
+ * 2. With modelFileId and propertyName: useModelProperty(modelFileId, propertyName)
+ * 3. With schemaId, modelName, and propertyName: useModelProperty(schemaId, modelName, propertyName)
+ *
+ * @overload
+ * @param propertyFileId - The property file ID (schemaFileId)
+ * @returns Object with modelProperty, isLoading, and error
+ *
+ * @overload
+ * @param modelFileId - The model file ID (modelFileId)
+ * @param propertyName - The name of the property
+ * @returns Object with modelProperty, isLoading, and error
+ *
+ * @overload
+ * @param schemaId - The schema ID (schema file ID)
+ * @param modelName - The name of the model
+ * @param propertyName - The name of the property
+ * @returns Object with modelProperty, isLoading, and error
+ */
+export declare function useModelProperty(propertyFileId: string): {
+    modelProperty: ModelProperty | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useModelProperty(modelFileId: string, propertyName: string): {
+    modelProperty: ModelProperty | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useModelProperty(schemaId: string, modelName: string, propertyName: string): {
+    modelProperty: ModelProperty | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};
+//# sourceMappingURL=modelProperty.d.ts.map

package/dist/src/browser/react/modelProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelProperty.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/modelProperty.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAY7D,KAAK,wBAAwB,GAAG;IAC9B,eAAe,EAAE,aAAa,EAAE,CAAA;IAChC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAC7B,mBAAmB,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,YAAY,MAAM,GAAG,IAAI,GAAG,SAAS,KACpC,wBAqNF,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG;IACxD,aAAa,EAAE,aAAa,GAAG,SAAS,CAAA;IACxC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA;AACD,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB;IACD,aAAa,EAAE,aAAa,GAAG,SAAS,CAAA;IACxC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA;AACD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB;IACD,aAAa,EAAE,aAAa,GAAG,SAAS,CAAA;IACxC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB,CAAA"}

package/dist/src/browser/react/schema.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "@/Schema/Schema";
+/**
+ * Hook to get a Schema class instance (with setters) that is reactive
+ * This allows you to edit schema properties directly like: schema.name = 'New name'
+ * The schema instance uses a Proxy to ensure React re-renders when properties change
+ * @param schemaIdentifier - The name of the schema or the schema file ID
+ *   - If a name is provided, retrieves the latest version with that name
+ *   - If an ID is provided, retrieves the specific schema by ID
+ * @returns Object with schema instance
+ */
+export declare const useSchema: (schemaIdentifier: string | null | undefined) => {
+    schema: Schema | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare const useSchemas: () => {
+    schemas: Schema[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare const useCreateSchema: () => {
+    createSchema: (schemaName: string) => Schema;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare const useAllSchemaVersions: () => Schema[] | null | undefined;
+/**
+ * Hook to get the internal Seed Protocol schema (SDK-only schema)
+ * This schema is managed by the SDK and should not be edited by app developers
+ * @returns Object with schema instance and schemaData (version, metadata, etc.)
+ */
+export declare const useSeedProtocolSchema: () => {
+    schema: Schema | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/browser/react/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAYxC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,kBAAkB,MAAM,GAAG,IAAI,GAAG,SAAS;;;;CAgFpE,CAAA;AAED,eAAO,MAAM,UAAU;;;;CAkOtB,CAAA;AAED,eAAO,MAAM,eAAe;+BAMoB,MAAM;;;CAwBrD,CAAA;AAED,eAAO,MAAM,oBAAoB,mCAyEhC,CAAA;AAKD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;CAEjC,CAAA"}

package/dist/src/browser/react/services.d.ts

@@ -1,4 +1,5 @@
 import { ActorRef } from 'xstate';
+import { ClientManagerState } from '@/client/constants';
 export declare const getServiceName: (service: ActorRef<any, any>) => string;
 export declare const getServiceValue: (service: ActorRef<any, any>) => string | undefined;
 export declare const getServiceUniqueKey: (service: ActorRef<any, any>) => any;
@@ -17,7 +18,7 @@ export declare const useServices: () => {
     percentComplete: number;
 };
 export declare const useGlobalServiceStatus: () => {
-    status: import("@/services/internal/constants").GlobalState | "savingPublishService";
-    internalStatus: any;
+    status: ClientManagerState;
+    internalStatus: string;
 };
 //# sourceMappingURL=services.d.ts.map

package/dist/src/browser/react/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/services.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAuB,MAAM,QAAQ,CAAA;AAiBtD,eAAO,MAAM,cAAc,YAAa,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,WASzD,CAAA;AAED,eAAO,MAAM,eAAe,YACjB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAC1B,MAAM,GAAG,SAmBX,CAAA;AAED,eAAO,MAAM,mBAAmB,YAAa,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,QAgC9D,CAAA;AAED,eAAO,MAAM,UAAU,YAAa,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;;;;;;CAgErD,CAAA;AAED,eAAO,MAAM,YAAY,eAmBxB,CAAA;AAED,eAAO,MAAM,qBAAqB,YAqDjC,CAAA;AAED,eAAO,MAAM,oBAAoB,eAyBhC,CAAA;AAED,eAAO,MAAM,WAAW;;;CA6FvB,CAAA;AAED,eAAO,MAAM,sBAAsB;;;CAyBlC,CAAA"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../../src/browser/react/services.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAuB,MAAM,QAAQ,CAAA;AAUtD,OAAO,EAAc,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAOnE,eAAO,MAAM,cAAc,GAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,WASzD,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAC1B,MAAM,GAAG,SAmBX,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,QAgC9D,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;;;;;;CAgErD,CAAA;AAED,eAAO,MAAM,YAAY,eAmBxB,CAAA;AAED,eAAO,MAAM,qBAAqB,YAqDjC,CAAA;AAED,eAAO,MAAM,oBAAoB,eAyBhC,CAAA;AAED,eAAO,MAAM,WAAW;;;CAiDvB,CAAA;AAED,eAAO,MAAM,sBAAsB;;;CA2BlC,CAAA"}

package/dist/src/browser/seed.d.ts

@@ -2,7 +2,6 @@ import { Snapshot } from 'xstate';
 import { SeedBase } from '@/shared/seed';
 import { SeedConstructorOptions } from '@/types';
 declare class SeedBrowser extends SeedBase {
-    private _internalProcess;
     constructor({ config: endpoints }: SeedConstructorOptions);
     notify(snapshot: Snapshot<any>): void;
     unload(): void;

package/dist/src/browser/seed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/browser/seed.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,QAAQ,EAAgB,MAAM,QAAQ,CAAA;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAIhD,cAAM,WAAY,SAAQ,QAAQ;IAChC,OAAO,CAAC,gBAAgB,CAAsC;gBAElD,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,sBAAsB;IAqBzD,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC;IAuB9B,MAAM;CAIP;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/browser/seed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgB,MAAM,QAAQ,CAAA;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAIhD,cAAM,WAAY,SAAQ,QAAQ;gBACpB,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,sBAAsB;IAczD,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC;IAuB9B,MAAM;CAKP;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/src/browser/workers/FileDownloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileDownloader.d.ts","sourceRoot":"","sources":["../../../../src/browser/workers/FileDownloader.ts"],"names":[],"mappings":"AAMA,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,cAAc,CAAe;IACrC,OAAO,CAAC,aAAa,CAAQ;;IAUtB,WAAW,0DAA+D,sBAAsB,KAAG,OAAO,CAAC,IAAI,CAAC,CA4CtH;CACF"}
+{"version":3,"file":"FileDownloader.d.ts","sourceRoot":"","sources":["../../../../src/browser/workers/FileDownloader.ts"],"names":[],"mappings":"AAMA,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,cAAc,CAAe;IACrC,OAAO,CAAC,aAAa,CAAQ;;IAUtB,WAAW,GAAU,uDAAqD,sBAAsB,KAAG,OAAO,CAAC,IAAI,CAAC,CA4CtH;CACF"}

package/dist/src/browser/workers/content-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content-hash.d.ts","sourceRoot":"","sources":["../../../../src/browser/workers/content-hash.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,eAAe,UAAkB,MAAM,KAAK,OAAO,CAAC,MAAM,CAa/D,CAAA"}
+{"version":3,"file":"content-hash.d.ts","sourceRoot":"","sources":["../../../../src/browser/workers/content-hash.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,eAAe,GAAW,OAAO,MAAM,KAAK,OAAO,CAAC,MAAM,CAa/D,CAAA"}

package/dist/src/client/ClientManager.d.ts

@@ -6,191 +6,195 @@ type ModelDefObj = {
     };
 };
 export declare const clientManager: import("xstate").Actor<import("xstate").StateMachine<import("..").ClientManagerContext, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+        type: "init";
+        options: import("..").SeedConstructorOptions;
+    }>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+        key: string;
+        value: any;
+    }, import("xstate").EventObject>> | undefined;
 }, {
-    src: "initialize";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
+    src: "platformClassesInit";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+        type: "init";
+        options: import("..").SeedConstructorOptions;
+    }>, import("xstate").EventObject>;
     id: string | undefined;
-}, {
-    type: "setAddresses";
-    params: import("xstate").NonReducibleUnknown;
-}, never, never, "uninitialized" | "initializing" | "idle", string, import("..").ClientManagerContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-    readonly id: "clientManager";
-    readonly initial: "uninitialized";
-    readonly context: ({ input }: {
-        spawn: {
-            <TSrc extends "initialize">(logic: TSrc, ...[options]: {
-                src: "initialize";
-                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                id: string | undefined;
-            } extends infer T ? T extends {
-                src: "initialize";
-                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                id: string | undefined;
-            } ? T extends {
-                src: TSrc;
-            } ? import("xstate").ConditionalRequired<[options?: ({
-                id?: T["id"] | undefined;
-                systemId?: string;
-                input?: import("xstate").InputFrom<T["logic"]> | undefined;
-                syncSnapshot?: boolean;
-            } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): import("xstate").ActorRefFromLogic<import("xstate").GetConcreteByKey<{
-                src: "initialize";
-                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                id: string | undefined;
-            }, "src", TSrc>["logic"]>;
-            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, ...[options]: import("xstate").ConditionalRequired<[options?: ({
-                id?: never;
-                systemId?: string;
-                input?: import("xstate").InputFrom<TLogic> | undefined;
-                syncSnapshot?: boolean;
-            } & { [K in import("xstate").RequiredLogicInput<TLogic>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredLogicInput<TLogic>>>): import("xstate").ActorRefFromLogic<TLogic>;
-        };
-        input: import("..").ClientManagerContext;
-        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("..").ClientManagerContext, import("xstate").AnyEventObject, Record<string, import("xstate").AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
-    }) => import("..").ClientManagerContext;
-    readonly states: {
-        readonly uninitialized: {
-            readonly on: {
-                readonly init: {
-                    readonly target: "initializing";
-                };
-            };
-        };
-        readonly initializing: {
-            readonly on: {
-                readonly initialized: {
-                    readonly target: "idle";
-                };
-            };
-            readonly invoke: {
-                readonly src: "initialize";
-                readonly input: ({ event, context }: {
-                    context: import("..").ClientManagerContext;
-                    event: import("xstate").AnyEventObject;
-                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("..").ClientManagerContext, import("xstate").AnyEventObject, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
-                }) => {
-                    event: import("xstate").AnyEventObject;
-                    context: import("..").ClientManagerContext;
-                };
-            };
-        };
-        readonly idle: {
-            readonly entry: import("xstate").ActionFunction<import("..").ClientManagerContext, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, {
-                src: "initialize";
-                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                id: string | undefined;
-            }, never, never, never, never>;
-            readonly on: {
-                readonly saveAppStateSuccess: {
-                    readonly actions: import("xstate").ActionFunction<import("..").ClientManagerContext, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, {
-                        src: "initialize";
-                        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                        id: string | undefined;
-                    }, never, never, never, never>;
-                };
-                readonly setAddresses: {
-                    readonly actions: readonly [{
-                        readonly type: "setAddresses";
-                    }];
-                };
-            };
-        };
+} | {
+    src: "fileSystemInit";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "dbInit";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "saveConfig";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "addModelsToStore";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "addModelsToDb";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "processSchemaFiles";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "saveAppState";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+        key: string;
+        value: any;
+    }, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, never, never, import("./constants").ClientManagerState, string, import("..").ClientManagerContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: import("./constants").MachineIds.CLIENT_MANAGER;
+    states: {
+        readonly uninitialized: {};
+        readonly platformClassesInit: {};
+        readonly fileSystemInit: {};
+        readonly dbInit: {};
+        readonly saveConfig: {};
+        readonly processSchemaFiles: {};
+        readonly addModelsToStore: {};
+        readonly addModelsToDb: {};
+        readonly idle: {};
     };
 }>>;
 export declare const ClientManager: {
     isInitialized: () => boolean;
     getService: () => import("xstate").Actor<import("xstate").StateMachine<import("..").ClientManagerContext, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>> | undefined;
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+            type: "init";
+            options: import("..").SeedConstructorOptions;
+        }>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            key: string;
+            value: any;
+        }, import("xstate").EventObject>> | undefined;
     }, {
-        src: "initialize";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
+        src: "platformClassesInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+            type: "init";
+            options: import("..").SeedConstructorOptions;
+        }>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "fileSystemInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "dbInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "saveConfig";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
         id: string | undefined;
+    } | {
+        src: "addModelsToStore";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "addModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "processSchemaFiles";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "saveAppState";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            key: string;
+            value: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, import("./constants").ClientManagerState, string, import("..").ClientManagerContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: import("./constants").MachineIds.CLIENT_MANAGER;
+        states: {
+            readonly uninitialized: {};
+            readonly platformClassesInit: {};
+            readonly fileSystemInit: {};
+            readonly dbInit: {};
+            readonly saveConfig: {};
+            readonly processSchemaFiles: {};
+            readonly addModelsToStore: {};
+            readonly addModelsToDb: {};
+            readonly idle: {};
+        };
+    }>>;
+    init: (options: any) => Promise<void>;
+    setAddresses: (addresses: string[]) => Promise<void>;
+    getAddresses: () => Promise<any>;
+    addModel: (modelDef: ModelDefObj) => Promise<void>;
+    onReady: (callback: () => void) => void;
+    stop: () => void;
+    unload: () => void;
+};
+export declare const getClient: () => {
+    isInitialized: () => boolean;
+    getService: () => import("xstate").Actor<import("xstate").StateMachine<import("..").ClientManagerContext, import("xstate").AnyEventObject, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+            type: "init";
+            options: import("..").SeedConstructorOptions;
+        }>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            key: string;
+            value: any;
+        }, import("xstate").EventObject>> | undefined;
     }, {
-        type: "setAddresses";
-        params: import("xstate").NonReducibleUnknown;
-    }, never, never, "uninitialized" | "initializing" | "idle", string, import("..").ClientManagerContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-        readonly id: "clientManager";
-        readonly initial: "uninitialized";
-        readonly context: ({ input }: {
-            spawn: {
-                <TSrc extends "initialize">(logic: TSrc, ...[options]: {
-                    src: "initialize";
-                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                    id: string | undefined;
-                } extends infer T ? T extends {
-                    src: "initialize";
-                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                    id: string | undefined;
-                } ? T extends {
-                    src: TSrc;
-                } ? import("xstate").ConditionalRequired<[options?: ({
-                    id?: T["id"] | undefined;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): import("xstate").ActorRefFromLogic<import("xstate").GetConcreteByKey<{
-                    src: "initialize";
-                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                    id: string | undefined;
-                }, "src", TSrc>["logic"]>;
-                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, ...[options]: import("xstate").ConditionalRequired<[options?: ({
-                    id?: never;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<TLogic> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K in import("xstate").RequiredLogicInput<TLogic>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredLogicInput<TLogic>>>): import("xstate").ActorRefFromLogic<TLogic>;
-            };
-            input: import("..").ClientManagerContext;
-            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("..").ClientManagerContext, import("xstate").AnyEventObject, Record<string, import("xstate").AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
-        }) => import("..").ClientManagerContext;
-        readonly states: {
-            readonly uninitialized: {
-                readonly on: {
-                    readonly init: {
-                        readonly target: "initializing";
-                    };
-                };
-            };
-            readonly initializing: {
-                readonly on: {
-                    readonly initialized: {
-                        readonly target: "idle";
-                    };
-                };
-                readonly invoke: {
-                    readonly src: "initialize";
-                    readonly input: ({ event, context }: {
-                        context: import("..").ClientManagerContext;
-                        event: import("xstate").AnyEventObject;
-                        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("..").ClientManagerContext, import("xstate").AnyEventObject, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("xstate").AnyEventObject, import("xstate").AnyEventObject>;
-                    }) => {
-                        event: import("xstate").AnyEventObject;
-                        context: import("..").ClientManagerContext;
-                    };
-                };
-            };
-            readonly idle: {
-                readonly entry: import("xstate").ActionFunction<import("..").ClientManagerContext, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, {
-                    src: "initialize";
-                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                    id: string | undefined;
-                }, never, never, never, never>;
-                readonly on: {
-                    readonly saveAppStateSuccess: {
-                        readonly actions: import("xstate").ActionFunction<import("..").ClientManagerContext, import("xstate").AnyEventObject, import("xstate").AnyEventObject, undefined, {
-                            src: "initialize";
-                            logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, import("xstate").EventObject>, import("xstate").EventObject>;
-                            id: string | undefined;
-                        }, never, never, never, never>;
-                    };
-                    readonly setAddresses: {
-                        readonly actions: readonly [{
-                            readonly type: "setAddresses";
-                        }];
-                    };
-                };
-            };
+        src: "platformClassesInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext, {
+            type: "init";
+            options: import("..").SeedConstructorOptions;
+        }>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "fileSystemInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "dbInit";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "saveConfig";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "addModelsToStore";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "addModelsToDb";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "processSchemaFiles";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("..").FromCallbackInput<import("..").ClientManagerContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    } | {
+        src: "saveAppState";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {
+            key: string;
+            value: any;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    }, never, never, never, import("./constants").ClientManagerState, string, import("..").ClientManagerContext, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+        id: import("./constants").MachineIds.CLIENT_MANAGER;
+        states: {
+            readonly uninitialized: {};
+            readonly platformClassesInit: {};
+            readonly fileSystemInit: {};
+            readonly dbInit: {};
+            readonly saveConfig: {};
+            readonly processSchemaFiles: {};
+            readonly addModelsToStore: {};
+            readonly addModelsToDb: {};
+            readonly idle: {};
         };
     }>>;
     init: (options: any) => Promise<void>;

package/dist/src/client/ClientManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClientManager.d.ts","sourceRoot":"","sources":["../../../src/client/ClientManager.ts"],"names":[],"mappings":"AAcA,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIxB,CAAA;AAeF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAQF,GAAG;8BAIO,MAAM,EAAE;;yBAab,WAAW;wBAYlB,MAAM,IAAI;;;CAiB/B,CAAA"}
+{"version":3,"file":"ClientManager.d.ts","sourceRoot":"","sources":["../../../src/client/ClientManager.ts"],"names":[],"mappings":"AAaA,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMxB,CAAA;AAwJF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA/HF,GAAG;8BAiFO,MAAM,EAAE;;yBAab,WAAW;wBAYlB,MAAM,IAAI;;;CAqBW,CAAA;AAE3C,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAjIE,GAAG;8BAiFO,MAAM,EAAE;;yBAab,WAAW;wBAYlB,MAAM,IAAI;;;CAyB/B,CAAA"}

package/dist/src/client/actors/addModelsToDb.d.ts

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

package/dist/src/client/actors/addModelsToDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addModelsToDb.d.ts","sourceRoot":"","sources":["../../../../src/client/actors/addModelsToDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAOlD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAM1E,eAAO,MAAM,aAAa,wGAoKxB,CAAA"}

package/dist/src/client/actors/addModelsToStore.d.ts

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

package/dist/src/client/actors/addModelsToStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addModelsToStore.d.ts","sourceRoot":"","sources":["../../../../src/client/actors/addModelsToStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAM1E,eAAO,MAAM,gBAAgB,wGA4B3B,CAAA"}

package/dist/src/client/actors/dbInit.d.ts

@@ -0,0 +1,4 @@
+import { ClientManagerContext, FromCallbackInput } from "@/types/machines";
+import { EventObject } from "xstate";
+export declare const dbInit: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ClientManagerContext>, EventObject>;
+//# sourceMappingURL=dbInit.d.ts.map