@kosdev-code/kos-ui-sdk 0.1.0-dev.5053

package/core/core/kosModelManager.d.ts

@@ -0,0 +1,207 @@
+import { IKosRegistry, KosCompanionModelType } from './types/registration';
+import { IKosModelManager } from './types/kos-model-manager-types';
+import { IKosDataModel, IKosDataModelBuilder, IKosModel } from './kosModel';
+import { BaseKosModelRegistrationBean } from '../types';
+
+export declare const MODEL_DELETION_DELAY = 10;
+export declare class KosModelManager implements IKosModelManager {
+    private cache;
+    private instantiator;
+    private dependencies;
+    private _registry;
+    private constructor();
+    static create(registry: IKosRegistry, reset?: boolean): KosModelManager;
+    static getInstance(reset?: boolean): KosModelManager;
+    get registry(): IKosRegistry;
+    /**
+     * Retrieves the preloaded models from the registry. If the models have already been
+     * preloaded, it returns the cached preloaded models. Otherwise, it initializes and
+     * preloads the models based on the registry's `preloadModels` configuration.
+     *
+     * @returns An array of preloaded model instances.
+     *
+     * @remarks
+     * - Logs debug information during the preloading process.
+     * - Logs an error if returning cached preloaded models.
+     * - Supports both string-based model keys and object-based model configurations.
+     */
+    get preloadedModels(): IKosModel<IKosDataModel>[];
+    get models(): IKosModel<IKosDataModel>[];
+    /**
+     * Retrieves a model by its unique identifier.
+     *
+     * @template T - The type of the data model extending `IKosDataModel`.
+     * @param id - The unique identifier of the model to retrieve.
+     * @returns The model associated with the given ID as `IKosModel<T>`, or `undefined` if the model is marked for deletion.
+     */
+    getModelById<T extends IKosDataModel>(id: string): IKosModel<T>;
+    /**
+     * Adds a model to the manager. If a model with the same ID already exists,
+     * it returns the existing model instead of adding the new one.
+     *
+     * @template T - The type of the data model extending `IKosDataModel`.
+     * @param model - The model to be added, implementing `IKosModel<T>`.
+     * @returns The active model, either the existing one with the same ID or the newly added model.
+     */
+    addModel<T extends IKosDataModel>(model: IKosModel<T>): IKosModel<T>;
+    /**
+     * Removes a model from the manager and performs cleanup operations.
+     *
+     * This method traverses the model hierarchy, invoking the `accept` method
+     * on each child model to allow for recursive processing. During traversal,
+     * it performs the following actions:
+     * - Calls the `offline` method on the model, if defined.
+     * - Clears any companion models associated with the model.
+     * - Deletes the model's context from the `KosContextManager`.
+     * - Removes the model from the internal `_modelsById` and `_toDelete` maps.
+     *
+     * @param model - The model to be removed. Must implement the `IKosModel` interface.
+     */
+    removeModel(model: IKosModel): void;
+    /**
+     * Checks if a model with the specified ID exists.
+     *
+     * @param modelId - The unique identifier of the model to check. Optional.
+     * @returns `true` if the model ID is provided and a model with the given ID exists; otherwise, `false`.
+     */
+    hasModel(modelId?: string): boolean;
+    /**
+     * Retrieves a list of models of a specific type that satisfy the provided filter criteria.
+     *
+     * @template T - The type of the data model extending `IKosDataModel`.
+     * @param typeId - The identifier of the model type to filter by.
+     * @param modelFilter - A callback function used to filter models. It receives a model of type `T` and should return `true` if the model passes the filter, or `false` otherwise.
+     * @returns An array of models of type `T` that match the specified type and filter criteria.
+     */
+    getModelsByType<T extends IKosDataModel>(typeId: string, modelFilter: (model: T) => boolean): T[];
+    /**
+     * Retrieves the subscriptions associated with a specific model type.
+     *
+     * @param typeId - The unique identifier of the model type.
+     * @returns An object containing the subscriptions for the specified model type,
+     *          or an empty object if the model type is not registered.
+     */
+    getModelSubscriptions(typeId: string): Record<string, import('./types/registration').IKosSubscriptionSpecification>;
+    /**
+     * Retrieves the data model builder for a specified model type.
+     *
+     * @template D - The type of the data used by the model.
+     * @template M - The type of the data model that extends `IKosDataModel`.
+     * @param typeId - The unique identifier for the model type.
+     * @returns An instance of `IKosDataModelBuilder` for the specified model type,
+     *          or `undefined` if the model type is not registered.
+     */
+    getDataModelBuilder<D, M extends IKosDataModel>(typeId: string): IKosDataModelBuilder<D, M>;
+    /**
+     * Retrieves a model factory function for the specified model type.
+     *
+     * @template T - The type of the data model that extends `IKosDataModel`.
+     * @param modelType - A string representing the type of the model.
+     * @returns A factory function for creating instances of the specified model type.
+     */
+    getModelFactory<T extends IKosDataModel>(modelType: string): import('../types').ModelFactory<T, {}>;
+    /**
+     * Adds a dependency relationship between two models.
+     *
+     * This method establishes a "uses" relationship where the model identified
+     * by `modelId` depends on the model identified by `dependencyId`. It ensures
+     * that the dependency is not marked for deletion and restores it from the
+     * delete cache if necessary. The relationship is then recorded in both the
+     * `_usedByCache` and `_usesCache` for efficient lookup.
+     *
+     * @param modelId - The identifier of the model that depends on the dependency.
+     * @param dependencyId - The identifier of the model being depended upon.
+     */
+    addDependency(modelId: string, dependencyId: string): void;
+    /**
+     * Removes a dependency relationship between two models.
+     *
+     * This method updates the internal caches to reflect that the specified
+     * `modelId` no longer depends on the `dependencyId`. It removes the
+     * `modelId` from the list of models that use the `dependencyId` and
+     * removes the `dependencyId` from the list of dependencies used by the
+     * `modelId`.
+     *
+     * @param modelId - The ID of the model that has the dependency.
+     * @param dependencyId - The ID of the dependency to be removed.
+     */
+    removeDependency(modelId: string, dependencyId: string): void;
+    /**
+     * Reloads the specified model by its ID. If the model exists and is found
+     * by its ID, it transitions the model to the RESETTING state using the
+     * RESET event.
+     *
+     * @param model - The data model to be reloaded. Must implement the `IKosDataModel` interface.
+     *                The `id` property of the model is used to locate the corresponding model.
+     *
+     * @returns A promise that resolves once the model has been transitioned, or does nothing
+     *          if the model ID is not provided or the model is not found.
+     */
+    reloadModel(model: IKosDataModel): Promise<void>;
+    /**
+     * Initiates the destruction process for a given model.
+     *
+     * This method checks if the model can be destroyed and, if so, schedules it for deletion.
+     * The model is removed from the internal `_modelsById` map and added to the `_toDelete` map.
+     * A deletion task is then queued with a delay, during which the model will be destroyed.
+     *
+     * @param model - The model to be destroyed. Must implement the `IKosDataModel` interface.
+     * @throws {Error} If the model does not have a valid `id`.
+     */
+    initiateDestroyModel(model: IKosDataModel): Promise<void>;
+    /**
+     * Destroys the specified model if it meets the criteria for destruction.
+     *
+     * @param model - The model to be destroyed, implementing the `IKosModel` interface.
+     *
+     * @remarks
+     * This method checks if the model has a valid `modelId` and if it can be destroyed
+     * by invoking the `canDestroyModel` method. If the conditions are met, it performs
+     * the following actions:
+     * 1. Calls the `unload` method on the model, if it exists.
+     * 2. Removes the model from the manager using the `removeModel` method.
+     *
+     * @throws This method does not explicitly throw errors, but any errors occurring
+     * during the `unload` or `removeModel` operations will propagate to the caller.
+     */
+    destroyModel(model: IKosModel): Promise<void>;
+    /**
+     * Creates an instance of a model based on the specified type ID and optional model ID.
+     * If the model already exists, it retrieves the existing instance; otherwise, it creates a new one.
+     *
+     * @template DataDef - The type of the data model, extending `IKosDataModel`.
+     * @param typeId - The unique identifier for the type of model to create.
+     * @param id - An optional unique identifier for the specific model instance. If not provided,
+     *             the `typeId` is used for singleton models.
+     * @param options - An optional record of additional options to pass to the model creation process.
+     * @returns An object containing the created or retrieved model instance and its associated data.
+     */
+    createModelInstance<DataDef extends IKosDataModel>(typeId: string, id?: string, options?: Record<string, any>): {
+        model: IKosModel<DataDef>;
+        data: DataDef;
+    };
+    /**
+     * Registers a companion model for a specific type identifier.
+     *
+     * This method ensures that the companion model is added to the registry
+     * for the given `typeId`. If a companion model of the same type already
+     * exists for the `typeId`, it will not be added again.
+     *
+     * @param typeId - The unique identifier for the type to which the companion model belongs.
+     * @param companionRegistration - The companion model type to register.
+     */
+    registerCompanionModel(typeId: string, companionRegistration: KosCompanionModelType<any>): void;
+    /**
+     * Registers a new model type in the model manager if it is not already registered.
+     *
+     * @template T - A type that extends `BaseKosModelRegistrationBean` with specific type and registration details.
+     * @param reg - The registration object containing the type identifier and registration details for the model.
+     *
+     * @remarks
+     * - If the model type is not already present in the registry, it logs the registration
+     *   and updates the registry with the new model type.
+     * - The `type` property of the registration object is used as the unique identifier for the model type.
+     */
+    registerModel<T extends BaseKosModelRegistrationBean<any, any>>(reg: T): void;
+}
+//# sourceMappingURL=kosModelManager.d.ts.map

package/core/core/kosModelManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kosModelManager.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-sdk/src/core/core/kosModelManager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAI7D,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAEhF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAIvC,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO;IA+BP,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,OAAO;IAQrD,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,eAAe;IAQpD,IAAI,QAAQ,iBAEX;IAED;;;;;;;;;;;OAWG;IACH,IAAI,eAAe,+BAalB;IAED,IAAI,MAAM,+BAET;IAED;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IAI/D;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAIpE;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAInC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM;IAIzB;;;;;;;OAOG;IACH,eAAe,CAAC,CAAC,SAAS,aAAa,EACrC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO;IAUpC;;;;;;OAMG;IACH,qBAAqB,CAAC,MAAM,EAAE,MAAM;IAIpC;;;;;;;;OAQG;IACH,mBAAmB,CAAC,CAAC,EAAE,CAAC,SAAS,aAAa,EAC5C,MAAM,EAAE,MAAM,GACb,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;IAI7B;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,MAAM;IAI1D;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAKnD;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAItD;;;;;;;;;;OAUG;IACG,WAAW,CAAC,KAAK,EAAE,aAAa;IAYtC;;;;;;;;;OASG;IACG,oBAAoB,CAAC,KAAK,EAAE,aAAa;IAc/C;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,KAAK,EAAE,SAAS;IAOnC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,OAAO,SAAS,aAAa,EAC/C,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;;;;IAKnC;;;;;;;;;OASG;IACH,sBAAsB,CACpB,MAAM,EAAE,MAAM,EACd,qBAAqB,EAAE,qBAAqB,CAAC,GAAG,CAAC;IAKnD;;;;;;;;;;OAUG;IACH,aAAa,CAAC,CAAC,SAAS,4BAA4B,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC;CAGvE"}

package/core/core/lifecycle/constants.d.ts

@@ -0,0 +1,37 @@
+export declare enum KosModelState {
+    CREATING = "creating",
+    CREATED = "created",
+    INITIALIZING = "initializing",
+    INITIALIZED = "initialized",
+    LOADING = "loading",
+    LOADED = "loaded",
+    ONLINE = "online",
+    READYING = "readying",
+    READY = "ready",
+    READY_FAILED = "ready_failed",
+    RESETTING = "resetting",
+    RESET = "reset",
+    OFFLINE = "offline",
+    UNLOADING = "unloading",
+    UNLOADED = "unloaded",
+    FAILED = "failed",
+    INACTIVE = "inactive",
+    ACTIVE = "active",
+    ACTIVATING = "activating",
+    DEACTIVATING = "deactivating"
+}
+export declare enum KosModelEvents {
+    CREATE = "create",
+    INITIALIZE = "init",
+    LOAD = "load",
+    READY = "ready",
+    GO_ONLINE = "go_online",
+    GO_OFFLINE = "go_offline",
+    RESET = "go_offline",
+    UNLOAD = "unload",
+    FAILED = "failed",
+    GO_ACTIVE = "go_active",
+    GO_INACTIVE = "go_inactive",
+    TIMEOUT = "timeout"
+}
+//# sourceMappingURL=constants.d.ts.map

package/core/core/lifecycle/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/constants.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IACvB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,UAAU,eAAe;IACzB,YAAY,iBAAiB;CAC9B;AAED,oBAAY,cAAc;IACxB,MAAM,WAAW;IACjB,UAAU,SAAS;IACnB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,UAAU,eAAe;IACzB,KAAK,eAAe;IACpB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}

package/core/core/lifecycle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/core/core/lifecycle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/core/core/lifecycle/kosCoreLifecycle.d.ts

@@ -0,0 +1,86 @@
+import { IKosCoreManager } from '../kosCore';
+
+export declare enum KosCoreState {
+    CREATING = "creating",
+    CREATED = "created",
+    INITIALIZING = "initializing",
+    INITIALIZED = "initialized",
+    LOADING = "loading",
+    LOADED = "loaded",
+    ONLINE = "online",
+    READYING = "readying",
+    READY = "ready",
+    OFFLINE = "offline",
+    UNLOADING = "unloading",
+    UNLOADED = "unloaded",
+    RELOADING = "reloading"
+}
+export declare enum KosCoreEvents {
+    CREATE = "create",
+    INITIALIZE = "init",
+    READY = "ready",
+    GO_ONLINE = "go_online",
+    GO_OFFLINE = "go_offline",
+    UNLOAD = "unload",
+    RELOAD = "reload"
+}
+export interface KosOn {
+    [k: string]: string;
+}
+export interface KosInvoke<Context> {
+    id: string;
+    src: (context: Context) => Promise<any>;
+    onDone: {
+        target: string;
+    };
+}
+export interface KosLifecycleState {
+    on: KosOn;
+}
+export interface KosLifecycleStateContainer<Context> {
+    [k: string]: {
+        initial?: string;
+        states?: KosLifecycleStateContainer<Context>;
+        on?: KosOn;
+        invoke?: KosInvoke<Context>;
+    };
+}
+export interface KosLifecycle<Context = any> {
+    id: string;
+    initial: string;
+    states: KosLifecycleStateContainer<Context>;
+    context: Context;
+}
+export declare const coreFsm: (core: IKosCoreManager) => {
+    service: import('robot3').Service<import('robot3').Machine<{
+        creating: import('robot3').MachineState;
+        created: import('robot3').MachineState;
+        initializing: import('robot3').MachineState;
+        initialized: import('robot3').MachineState;
+        loading: import('robot3').MachineState;
+        loaded: import('robot3').MachineState;
+        readying: import('robot3').MachineState;
+        reloading: import('robot3').MachineState;
+        ready: import('robot3').MachineState;
+        unloaded: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        creating: unknown;
+        created: unknown;
+        initializing: unknown;
+        initialized: unknown;
+        loading: unknown;
+        loaded: unknown;
+        readying: unknown;
+        reloading: unknown;
+        ready: unknown;
+        unloaded: unknown;
+    }>>>;
+    online: import('robot3').Service<import('robot3').Machine<{
+        online: import('robot3').MachineState;
+        offline: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        online: unknown;
+        offline: unknown;
+    }>>>;
+};
+//# sourceMappingURL=kosCoreLifecycle.d.ts.map

package/core/core/lifecycle/kosCoreLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kosCoreLifecycle.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/kosCoreLifecycle.ts"],"names":[],"mappings":";AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,oBAAY,YAAY;IACtB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,SAAS,cAAc;CACxB;AAED,oBAAY,aAAa;IACvB,MAAM,WAAW;IACjB,UAAU,SAAS;IACnB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,UAAU,eAAe;IACzB,MAAM,WAAW;IACjB,MAAM,WAAW;CAClB;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS,CAAC,OAAO;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACxC,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AACD,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,KAAK,CAAC;CACX;AACD,MAAM,WAAW,0BAA0B,CAAC,OAAO;IACjD,CAAC,CAAC,EAAE,MAAM,GAAG;QACX,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;QAC7C,EAAE,CAAC,EAAE,KAAK,CAAC;QACX,MAAM,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAC7B,CAAC;CACH;AAED,MAAM,WAAW,YAAY,CAAC,OAAO,GAAG,GAAG;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC5C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,OAAO,SAAU,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiG5C,CAAC"}

package/core/core/lifecycle/kosModelLifecycle.d.ts

@@ -0,0 +1,57 @@
+import { IKosModel } from '../kosModel';
+
+export interface KosOn {
+    [k: string]: string;
+}
+export interface KosInvoke<Context> {
+    id: string;
+    src: (context: Context) => Promise<any>;
+    onDone: {
+        target: string;
+    };
+}
+export interface KosLifecycleState {
+    on: KosOn;
+}
+export interface KosLifecycleStateContainer<Context> {
+    [k: string]: {
+        initial?: string;
+        states?: KosLifecycleStateContainer<Context>;
+        on?: KosOn;
+        invoke?: KosInvoke<Context>;
+    };
+}
+export interface KosLifecycle<Context = any> {
+    id: string;
+    initial: string;
+    states: KosLifecycleStateContainer<Context>;
+    context: Context;
+}
+export declare const fsm: (model: IKosModel) => {
+    service: import('robot3').Service<import('robot3').Machine<{
+        creating: import('robot3').MachineState;
+        created: import('robot3').MachineState;
+        initializing: import('robot3').MachineState;
+        initialized: import('robot3').MachineState;
+        loading: import('robot3').MachineState;
+        loaded: import('robot3').MachineState;
+        resetting: import('robot3').MachineState;
+        readying: import('robot3').MachineState;
+        ready: import('robot3').MachineState;
+        unloaded: import('robot3').MachineState;
+        failed: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        creating: unknown;
+        created: unknown;
+        initializing: unknown;
+        initialized: unknown;
+        loading: unknown;
+        loaded: unknown;
+        resetting: unknown;
+        readying: unknown;
+        ready: unknown;
+        unloaded: unknown;
+        failed: unknown;
+    }>>>;
+};
+//# sourceMappingURL=kosModelLifecycle.d.ts.map

package/core/core/lifecycle/kosModelLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kosModelLifecycle.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/kosModelLifecycle.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAK7C,MAAM,WAAW,KAAK;IACpB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS,CAAC,OAAO;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACxC,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AACD,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,KAAK,CAAC;CACX;AACD,MAAM,WAAW,0BAA0B,CAAC,OAAO;IACjD,CAAC,CAAC,EAAE,MAAM,GAAG;QACX,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;QAC7C,EAAE,CAAC,EAAE,KAAK,CAAC;QACX,MAAM,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAC7B,CAAC;CACH;AAED,MAAM,WAAW,YAAY,CAAC,OAAO,GAAG,GAAG;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC5C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,GAAG,UAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CAQnC,CAAC"}

package/core/core/lifecycle/model-active-machine.d.ts

@@ -0,0 +1,31 @@
+import { IKosModel } from '../kosModel';
+
+export declare const activeMachine: (model: IKosModel) => {
+    service: import('robot3').Service<import('robot3').Machine<{
+        failed: import('robot3').MachineState;
+        inactive: import('robot3').MachineState;
+        activating: import('robot3').MachineState;
+        active: import('robot3').MachineState;
+        deactivating: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        failed: unknown;
+        inactive: unknown;
+        activating: unknown;
+        active: unknown;
+        deactivating: unknown;
+    }>>>;
+    machine: import('robot3').Machine<{
+        failed: import('robot3').MachineState;
+        inactive: import('robot3').MachineState;
+        activating: import('robot3').MachineState;
+        active: import('robot3').MachineState;
+        deactivating: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        failed: unknown;
+        inactive: unknown;
+        activating: unknown;
+        active: unknown;
+        deactivating: unknown;
+    }>>;
+};
+//# sourceMappingURL=model-active-machine.d.ts.map

package/core/core/lifecycle/model-active-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-active-machine.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/model-active-machine.ts"],"names":[],"mappings":";AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,eAAO,MAAM,aAAa,UAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyD7C,CAAC"}

package/core/core/lifecycle/model-machine.d.ts

@@ -0,0 +1,28 @@
+import { IKosModel } from '../kosModel';
+
+export declare const machine: (model: IKosModel) => import('robot3').Machine<{
+    creating: import('robot3').MachineState;
+    created: import('robot3').MachineState;
+    initializing: import('robot3').MachineState;
+    initialized: import('robot3').MachineState;
+    loading: import('robot3').MachineState;
+    loaded: import('robot3').MachineState;
+    resetting: import('robot3').MachineState;
+    readying: import('robot3').MachineState;
+    ready: import('robot3').MachineState;
+    unloaded: import('robot3').MachineState;
+    failed: import('robot3').MachineState;
+}, {}, import('robot3').AllStateKeys<{
+    creating: unknown;
+    created: unknown;
+    initializing: unknown;
+    initialized: unknown;
+    loading: unknown;
+    loaded: unknown;
+    resetting: unknown;
+    readying: unknown;
+    ready: unknown;
+    unloaded: unknown;
+    failed: unknown;
+}>>;
+//# sourceMappingURL=model-machine.d.ts.map

package/core/core/lifecycle/model-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-machine.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/model-machine.ts"],"names":[],"mappings":";AASA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,eAAO,MAAM,OAAO,UAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;GAkJvC,CAAC"}

package/core/core/lifecycle/model-online-machine.d.ts

@@ -0,0 +1,19 @@
+import { IKosModel } from '../kosModel';
+
+export declare const onlineMachine: (model: IKosModel) => {
+    machine: import('robot3').Machine<{
+        online: import('robot3').MachineState;
+        offline: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        online: unknown;
+        offline: unknown;
+    }>>;
+    service: import('robot3').Service<import('robot3').Machine<{
+        online: import('robot3').MachineState;
+        offline: import('robot3').MachineState;
+    }, {}, import('robot3').AllStateKeys<{
+        online: unknown;
+        offline: unknown;
+    }>>>;
+};
+//# sourceMappingURL=model-online-machine.d.ts.map

package/core/core/lifecycle/model-online-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-online-machine.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/lifecycle/model-online-machine.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,eAAO,MAAM,aAAa,UAAW,SAAS;;;;;;;;;;;;;;;CAkC7C,CAAC"}

package/core/core/log/index.d.ts

@@ -0,0 +1,2 @@
+export * from './log';
+//# sourceMappingURL=index.d.ts.map

package/core/core/log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/log/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}

package/core/core/log/log.d.ts

@@ -0,0 +1,36 @@
+import { default as log } from 'loglevel';
+
+export declare const KosLog: {
+    ifDebug: (fn: VoidFunction) => void;
+    ifInfo: (fn: VoidFunction) => void;
+    ifWarn: (fn: VoidFunction) => void;
+    ifError: (fn: VoidFunction) => void;
+    getLogger: (name: string) => log.Logger;
+    getLoggers: () => {
+        [name: string]: log.Logger;
+    };
+    createLogger: ({ name, group }: {
+        name: string;
+        group?: string;
+    }) => log.Logger;
+    wsSend: (...msg: any[]) => void;
+    wsReceive: (...msg: any[]) => void;
+    noConflict(): any;
+    default: log.RootLogger;
+    levels: log.LogLevel;
+    methodFactory: log.MethodFactory;
+    trace(...msg: any[]): void;
+    debug(...msg: any[]): void;
+    log(...msg: any[]): void;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    setLevel(level: log.LogLevelDesc, persist?: boolean | undefined): void;
+    getLevel(): 0 | 1 | 2 | 3 | 4 | 5;
+    setDefaultLevel(level: log.LogLevelDesc): void;
+    resetLevel(): void;
+    enableAll(persist?: boolean | undefined): void;
+    disableAll(persist?: boolean | undefined): void;
+    rebuild(): void;
+};
+//# sourceMappingURL=log.d.ts.map

package/core/core/log/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/log/log.ts"],"names":[],"mappings":"AAAA,OAAO,GAAiB,MAAM,UAAU,CAAC;AA8FzC,eAAO,MAAM,MAAM;kBALyB,YAAY;iBAAZ,YAAY;iBAAZ,YAAY;kBAAZ,YAAY;sBAYpC,MAAM;;;;oCAEQ;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;qBAkB/C,GAAG,EAAE;wBAIF,GAAG,EAAE;;;;;;;;;;;;;;;;;;CAI1B,CAAC"}

package/core/core/model/apply-kos-dev-tool-support.d.ts

@@ -0,0 +1,2 @@
+export declare function applyKosModelDevtoolsSupport(model: any): void;
+//# sourceMappingURL=apply-kos-dev-tool-support.d.ts.map

package/core/core/model/apply-kos-dev-tool-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-kos-dev-tool-support.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/apply-kos-dev-tool-support.ts"],"names":[],"mappings":"AAIA,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,GAAG,QAqEtD"}

package/core/core/model/kos-child-resolver.d.ts

@@ -0,0 +1,10 @@
+import { IKosModel } from '../kosModel';
+
+export declare class KosChildResolver {
+    private readonly model;
+    constructor(model: IKosModel);
+    resolve(): IKosModel[];
+    private getResolvedDecoratedChildren;
+    private getAdditionalChildren;
+}
+//# sourceMappingURL=kos-child-resolver.d.ts.map

package/core/core/model/kos-child-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-child-resolver.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/kos-child-resolver.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,SAAS,EAAE,MAAM,aAAa,CAAC;AAIvD,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,SAAS;IAE7C,OAAO,IAAI,SAAS,EAAE;IA6BtB,OAAO,CAAC,4BAA4B;IAQpC,OAAO,CAAC,qBAAqB;CAG9B"}

package/core/core/model/kos-companion-model-manager.d.ts

@@ -0,0 +1,14 @@
+import { IKosModel } from '../kosModel';
+import { ObservableMap } from 'mobx';
+
+export declare class KosCompanionModelManager {
+    private readonly hostModel;
+    private readonly companions;
+    constructor(hostModel: IKosModel);
+    add(model: IKosModel): void;
+    clear(): void;
+    get(modelTypeName: string): IKosModel | undefined;
+    all(): IKosModel[];
+    get data(): ObservableMap<string, IKosModel<import('../kosModel').IKosDataModel>>;
+}
+//# sourceMappingURL=kos-companion-model-manager.d.ts.map

package/core/core/model/kos-companion-model-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-companion-model-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/kos-companion-model-manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,qBAAa,wBAAwB;IAGvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0C;gBAExC,SAAS,EAAE,SAAS;IAEjD,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAI3B,KAAK,IAAI,IAAI;IAIb,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIjD,GAAG,IAAI,SAAS,EAAE;IAIlB,IAAI,IAAI,0EAEP;CACF"}

package/core/core/model/kos-effects-manager.d.ts

@@ -0,0 +1,14 @@
+import { KosOfflineQueueLogger } from './kos-offline-queue';
+
+export declare class KosEffectManager {
+    private modelTypeName;
+    private modelId;
+    private modelData;
+    private log;
+    private disposers;
+    constructor(modelTypeName: string, modelId: string, modelData: any, // typically IKosDataModel
+    log: KosOfflineQueueLogger);
+    setup(): void;
+    disposeAll(): void;
+}
+//# sourceMappingURL=kos-effects-manager.d.ts.map

package/core/core/model/kos-effects-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-effects-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/kos-effects-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IANb,OAAO,CAAC,SAAS,CAAsB;gBAG7B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,GAAG,EAAE,0BAA0B;IAC1C,GAAG,EAAE,qBAAqB;IAGpC,KAAK,IAAI,IAAI;IAwBb,UAAU,IAAI,IAAI;CAUnB"}

package/core/core/model/kos-fsm-manager.d.ts

@@ -0,0 +1,24 @@
+import { KosOfflineQueueLogger } from './kos-offline-queue';
+import { KosModelEvents, KosModelState } from '../lifecycle/constants';
+import { IKosModel } from '../kosModel';
+
+export declare class KosFSMManager {
+    private model;
+    private log;
+    private disposer?;
+    private readonly service;
+    constructor(model: IKosModel, log: KosOfflineQueueLogger);
+    /**
+     * Returns the current raw state of the FSM
+     */
+    get current(): KosModelState;
+    /**
+     * Waits for a transition to complete to the target state (or fails if error state reached)
+     */
+    transitionTo(event: KosModelEvents, target: KosModelState, error?: KosModelState): Promise<void>;
+    /**
+     * Checks if a given target maps to status or activeStatus
+     */
+    private getTransitionStatusFor;
+}
+//# sourceMappingURL=kos-fsm-manager.d.ts.map

package/core/core/model/kos-fsm-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-fsm-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/kos-fsm-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,qBAAa,aAAa;IAIZ,OAAO,CAAC,KAAK;IAAa,OAAO,CAAC,GAAG;IAHjD,OAAO,CAAC,QAAQ,CAAC,CAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;gBAExC,KAAK,EAAE,SAAS,EAAU,GAAG,EAAE,qBAAqB;IAMxE;;OAEG;IACH,IAAI,OAAO,IAAI,aAAa,CAE3B;IAED;;OAEG;IACG,YAAY,CAChB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,aAAa,EACrB,KAAK,GAAE,aAAoC,GAC1C,OAAO,CAAC,IAAI,CAAC;IAkDhB;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAK/B"}