@kosdev-code/kos-ui-sdk 2.0.2

package/models/models/state-prop/state-prop-model.d.ts

@@ -0,0 +1,19 @@
+import { KosStateProp, StatePropOptions } from './types';
+import { StatePropertyTypes } from '../types';
+import { StateBeanModel } from '../state-bean/types';
+import { IKosModelLogger, KosContextLogger, KosCreationContext } from '../../../core';
+
+export declare const MODEL_TYPE = "state-prop-model";
+export declare class StatePropModelImpl<T extends StatePropertyTypes = any> implements KosStateProp<T>, IKosModelLogger {
+    id: string;
+    path: string;
+    attribute: string;
+    logger: KosContextLogger;
+    stateBean: StateBeanModel;
+    constructor(modelId: string, options: StatePropOptions, context: KosCreationContext);
+    get value(): T | undefined;
+    init(): Promise<void>;
+    load(): Promise<void>;
+    toString(): string;
+}
+//# sourceMappingURL=state-prop-model.d.ts.map

package/models/models/state-prop/state-prop-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-prop-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-prop/state-prop-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9D,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAG7C,qBACa,kBAAkB,CAAC,CAAC,SAAS,kBAAkB,GAAG,GAAG,CAChE,YAAW,YAAY,CAAC,CAAC,CAAC,EAAE,eAAe;IAE3C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,gBAAgB,CAAC;IAOzB,SAAS,EAAG,cAAc,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAW7B,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,CAEzB;IAIK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,QAAQ,IAAI,MAAM;CAGnB"}

package/models/models/state-prop/state-prop-registration.d.ts

@@ -0,0 +1,84 @@
+import { KosStateProp, StatePropOptions } from './types';
+import { KosModelRegistrationBean } from '../../../core';
+
+/**
+ * # StateProp
+ *
+ * The registration bean includes convenience methods for creating and working with StatePropModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: StateProp.type, id: "statePropId"})
+ * private statePropModel: StatePropModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StatePropModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = StateProp.factory("statePropId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a StatePropModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StateProp.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StatePropModel
+ *    // and the compiler will know that the model has the StatePropModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { StateProp } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...StateProp.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The stateProp model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const StateProp: Readonly<KosModelRegistrationBean<KosStateProp, StatePropOptions>>;
+//# sourceMappingURL=state-prop-registration.d.ts.map

package/models/models/state-prop/state-prop-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-prop-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-prop/state-prop-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,wBAAwB,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAWzD,CAAC"}

package/models/models/state-prop/types/index.d.ts

@@ -0,0 +1,20 @@
+import { StatePropertyTypes } from '../../types';
+import { IKosDataModel } from '../../../core';
+
+
+export interface StatePropOptions {
+  path: string;
+  attribute: string;
+}
+
+/**
+ * State Property Model manages the state of a single state bean property
+ * @category Model
+ */
+
+export interface KosStateProp<T extends StatePropertyTypes = any>
+  extends StatePropOptions,
+    IKosDataModel {
+  id: string;
+  value: T | undefined;
+}

package/models/models/storage-device/index.d.ts

@@ -0,0 +1,7 @@
+export { StorageDeviceContainer } from './storage-device-container-registration';
+export { StorageDevice } from './storage-device-registration';
+export type * from './types';
+export type { StorageDeviceModel } from './storage-device-model';
+export type { StorageDeviceContainerModel } from './storage-device-container-model';
+export * as StorageDeviceServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/storage-device/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,YAAY,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,KAAK,qBAAqB,MAAM,YAAY,CAAC"}

package/models/models/storage-device/services/index.d.ts

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

package/models/models/storage-device/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/models/models/storage-device/services/storage-device-services.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @internal
+ */
+export interface StorageDeviceResponse {
+    mountDir: string;
+    removed: boolean;
+    id: string;
+    vendor: string;
+    runTimeMs: number;
+    model: string;
+    nodeId: string;
+    local: boolean;
+    label: string;
+    syspath: string;
+}
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial storage-device data.
+ */
+export declare const getStorageDevices: () => Promise<StorageDeviceResponse[]>;
+//# sourceMappingURL=storage-device-services.d.ts.map

package/models/models/storage-device/services/storage-device-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/services/storage-device-services.ts"],"names":[],"mappings":"AAAA;;GAEG;AAcH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AACD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,wCAQ7B,CAAC"}

package/models/models/storage-device/storage-device-container-model.d.ts

@@ -0,0 +1,31 @@
+import { StorageDeviceContainerOptions } from './types';
+import { StorageDeviceModel } from './storage-device-model';
+import { StorageDeviceResponse } from './services';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+import { IKosModelContainer } from '../../../core/core/kos-container-model';
+import { IKosIdentifiable, IKosModelHolder, PublicModelInterface } from '../../../core';
+
+export declare const MODEL_TYPE = "storage-device-container-model";
+export declare const TOPIC_STORAGE_AVAILABILITY = "/kos/storage";
+export type StorageDeviceContainerModel = PublicModelInterface<StorageDeviceContainerModelImpl>;
+/**
+ * Storage Device Container Model
+ * @category Model
+ */
+export declare class StorageDeviceContainerModelImpl implements IKosIdentifiable, IKosModelHolder<StorageDeviceModel>, IKosDataModel {
+    id: string;
+    private logger;
+    private _models;
+    constructor(modelId: string, options: StorageDeviceContainerOptions, context: KosCreationContext);
+    getModel(id: string): StorageDeviceModel | undefined;
+    get models(): IKosModelContainer<StorageDeviceModel>;
+    get data(): StorageDeviceModel[];
+    addModel(model: StorageDeviceModel): void;
+    removeModel(id: string): void;
+    init(): Promise<void>;
+    get isStorageInserted(): boolean;
+    get volumes(): StorageDeviceModel[];
+    handleStorageAvailability(devices: StorageDeviceResponse[]): void;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=storage-device-container-model.d.ts.map

package/models/models/storage-device/storage-device-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAIpB,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,kBAAkB,EACxB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAqB,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EACV,6BAA6B,EAE9B,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,UAAU,mCAAmC,CAAC;AAE3D,eAAO,MAAM,0BAA0B,iBAAiB,CAAC;AAEzD,MAAM,MAAM,2BAA2B,GACrC,oBAAoB,CAAC,+BAA+B,CAAC,CAAC;AAExD;;;GAGG;AACH,qBACa,+BACX,YACE,gBAAgB,EAChB,eAAe,CAAC,kBAAkB,CAAC,EACnC,aAAa;IAEf,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,OAAO,CAAyC;gBAEhE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,6BAA6B,EACtC,OAAO,EAAE,kBAAkB;IAY7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,2CAET;IACD,IAAI,IAAI,yBAEP;IAED,QAAQ,CAAC,KAAK,EAAE,kBAAkB;IAIlC,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,IAAI,iBAAiB,YAEpB;IAED,IAAI,OAAO,yBAEV;IAMD,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,EAAE;IA6BpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAc5B"}

package/models/models/storage-device/storage-device-container-registration.d.ts

@@ -0,0 +1,86 @@
+import { StorageDeviceContainerModel } from './storage-device-container-model';
+import { SingletonKosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # StorageDeviceContainer
+ *
+ * The registration bean includes convenience methods for creating and working with StorageDeviceContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: StorageDeviceContainer.type, id: "storageDeviceContainerId"})
+ * private storageDeviceContainerModel: StorageDeviceContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StorageDeviceContainerModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = StorageDeviceContainer.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a StorageDeviceContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StorageDeviceContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StorageDeviceContainerModel
+ *    // and the compiler will know that the model has the StorageDeviceContainerModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { StorageDeviceContainer } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...StorageDeviceContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The storageDeviceContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const StorageDeviceContainer: SingletonKosModelRegistrationFactory<StorageDeviceContainerModel, object>;
+//# sourceMappingURL=storage-device-container-registration.d.ts.map

package/models/models/storage-device/storage-device-container-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAQpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,sBAAsB,2EAMjC,CAAC"}

package/models/models/storage-device/storage-device-model.d.ts

@@ -0,0 +1,27 @@
+import { StorageDeviceOptions } from './types';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../core';
+
+export declare const MODEL_TYPE = "storage-device-model";
+export type StorageDeviceModel = PublicModelInterface<StorageDeviceModelImpl>;
+/**
+ * Storage Device Model
+ * @category Model
+ */
+export declare class StorageDeviceModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    mountDir: string;
+    removed: boolean;
+    vendor: string;
+    runTimeMs: number;
+    model: string;
+    nodeId: string;
+    local: boolean;
+    label: string;
+    syspath: string;
+    private logger;
+    constructor(modelId: string, options: StorageDeviceOptions, context: KosCreationContext);
+    updateModel(options: StorageDeviceOptions): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+//# sourceMappingURL=storage-device-model.d.ts.map

package/models/models/storage-device/storage-device-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E;;;GAGG;AACH,qBAEa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IAEjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAe7B,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAc1C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/storage-device/storage-device-registration.d.ts

@@ -0,0 +1,87 @@
+import { StorageDeviceOptions } from './types';
+import { StorageDeviceModel } from './storage-device-model';
+import { KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # StorageDevice
+ *
+ * The registration bean includes convenience methods for creating and working with StorageDeviceModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: StorageDevice.type, id: "storageDeviceId"})
+ * private storageDeviceModel: StorageDeviceModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StorageDeviceModel instances.
+ *
+ 
+ * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
+ *
+ * If a model with the specified id already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = StorageDevice.factory("storageDeviceId")({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a StorageDeviceModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StorageDevice.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StorageDeviceModel
+ *    // and the compiler will know that the model has the StorageDeviceModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { StorageDevice } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(StorageDevice);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The storageDevice model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const StorageDevice: KosModelRegistrationFactory<StorageDeviceModel, StorageDeviceOptions>;
+//# sourceMappingURL=storage-device-registration.d.ts.map

package/models/models/storage-device/storage-device-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,aAAa,uEAMxB,CAAC"}

package/models/models/storage-device/types/index.d.ts

@@ -0,0 +1,20 @@
+import { KosParentAware } from '../../../../core';
+
+
+// ---------------  StorageDevice ---------------
+
+export interface StorageDeviceOptions extends KosParentAware {
+  mountDir: string;
+  removed: boolean;
+  vendor: string;
+  runTimeMs: number;
+  model: string;
+  nodeId: string;
+  local: boolean;
+  label: string;
+  syspath: string;
+}
+
+// ---------------  StorageDeviceContainer ---------------
+
+export type StorageDeviceContainerOptions = object;

package/models/models/translation/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CONTEXT_LANG_RESOLVER = "langResolver";
+//# sourceMappingURL=constants.d.ts.map

package/models/models/translation/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,iBAAiB,CAAC"}

package/models/models/translation/index.d.ts

@@ -0,0 +1,9 @@
+export { getKosLocalizationDescriptor, getLocalizationDescriptor, getTranslations, } from './services';
+export type { Localization } from './services';
+export type { TranslationContainerModel } from './translation-container-model';
+export { TranslationContainer } from './translation-container-registration';
+export * from './translation-context';
+export type { ResolveTranslationOptions, TranslationModel, } from './translation-model';
+export { Translation } from './translation-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/translation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,yBAAyB,EACzB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,YAAY,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,cAAc,uBAAuB,CAAC;AACtC,YAAY,EACV,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,mBAAmB,SAAS,CAAC"}

package/models/models/translation/services/index.d.ts

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

package/models/models/translation/services/index.d.ts.map

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

package/models/models/translation/services/translation-services.d.ts

@@ -0,0 +1,25 @@
+export type TranslationResponse = Record<string, any>;
+export interface LocaleDescriptor {
+    defaultLocale: string;
+    file: string;
+    fallbacks?: string[];
+}
+export interface Localization {
+    namespaces: {
+        [key: string]: {
+            locales: {
+                [key: string]: LocaleDescriptor;
+            };
+            basePath: string;
+        };
+    };
+    path: string;
+}
+/**
+ * @category Service
+ * Retrieves the initial translation data.
+ */
+export declare const getTranslations: (url: string, root?: string) => Promise<any>;
+export declare const getLocalizationDescriptor: () => Promise<Localization>;
+export declare const getKosLocalizationDescriptor: (context: string) => () => Promise<Localization>;
+//# sourceMappingURL=translation-services.d.ts.map

package/models/models/translation/services/translation-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/services/translation-services.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AACD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,OAAO,EAAE;gBACP,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAC;aACjC,CAAC;YACF,QAAQ,EAAE,MAAM,CAAC;SAClB,CAAC;KACH,CAAC;IACF,IAAI,EAAE,MAAM,CAAC;CACd;AASD;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAe,MAAM,SAAS,MAAM,iBAgB/D,CAAC;AAEF,eAAO,MAAM,yBAAyB,6BAYrC,CAAC;AAEF,eAAO,MAAM,4BAA4B,YAAa,MAAM,gCAY3D,CAAC"}

package/models/models/translation/translation-container-model.d.ts

@@ -0,0 +1,36 @@
+import { TranslationContainerOptions } from './types';
+import { TranslationModel } from './translation-model';
+import { Localization } from './services';
+import { IKosDataModel, IKosIdentifiable, IKosModelContainer, IKosModelHolder, KosCreationContext, ReloadAware } from '../../../core';
+
+export declare const MODEL_TYPE = "translation-container-model";
+type PublicInterface<T> = {
+    [P in keyof T]: T[P];
+};
+export type TranslationContainerModel = PublicInterface<Exclude<TranslationContainerModelImpl, keyof IKosDataModel>>;
+export declare class TranslationContainerModelImpl implements IKosIdentifiable, IKosModelHolder<TranslationModel>, IKosDataModel, ReloadAware {
+    id: string;
+    lang: string;
+    private rootUrl?;
+    descriptor: Localization;
+    private _defaultNamespace?;
+    private resolver;
+    private logger;
+    private descriptorUrl?;
+    private namespaces;
+    private _models;
+    constructor(modelId: string, options: TranslationContainerOptions, context: KosCreationContext);
+    set currentLocale(locale: string);
+    get defaultNamespace(): import('./translation-model').TranslationModelImpl | undefined;
+    getModel(id: string): import('./translation-model').TranslationModelImpl | undefined;
+    get models(): IKosModelContainer<import('./translation-model').TranslationModelImpl>;
+    get data(): import('./translation-model').TranslationModelImpl[];
+    reload(): Promise<void>;
+    resolveNamespace(namespace: string): import('./translation-model').TranslationModelImpl;
+    addModel(model: TranslationModel): void;
+    removeModel(id: string): void;
+    init(): Promise<void>;
+    load(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=translation-container-model.d.ts.map

package/models/models/translation/translation-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/translation-container-model.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEf,kBAAkB,EAClB,WAAW,EACZ,MAAM,eAAe,CAAC;AAWvB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D,eAAO,MAAM,UAAU,gCAAgC,CAAC;AACxD,KAAK,eAAe,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,eAAe,CACrD,OAAO,CAAC,6BAA6B,EAAE,MAAM,aAAa,CAAC,CAC5D,CAAC;AAmBF,qBACa,6BACX,YACE,gBAAgB,EAChB,eAAe,CAAC,gBAAgB,CAAC,EACjC,aAAa,EACb,WAAW;IAEb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,UAAU,EAAE,YAAY,CAAC;IACzB,OAAO,CAAC,iBAAiB,CAAC,CAAS;IACnC,OAAO,CAAC,QAAQ,CAIJ;IACZ,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,UAAU,CAAgB;IACxB,OAAO,CAAC,OAAO,CAAuC;gBAE9D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,2BAA2B,EACpC,OAAO,EAAE,kBAAkB;IAiB7B,IAAI,aAAa,CAAC,MAAM,EAAE,MAAM,EAK/B;IACD,IAAI,gBAAgB,mEAInB;IACD,QAAQ,CAAC,EAAE,EAAE,MAAM;IAInB,IAAI,MAAM,2EAET;IACD,IAAI,IAAI,yDAEP;IAEK,MAAM;IAQZ,gBAAgB,CAAC,SAAS,EAAE,MAAM;IA4ClC,QAAQ,CAAC,KAAK,EAAE,gBAAgB;IAIhC,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/translation/translation-container-registration.d.ts

@@ -0,0 +1,87 @@
+import { TranslationContainerOptions } from './types';
+import { TranslationContainerModel } from './translation-container-model';
+import { SingletonKosModelRegistrationBean } from '../../../core';
+
+/**
+ * # TranslationContainer
+ *
+ * The registration bean includes convenience methods for creating and working with TranslationContainerModel instances.
+ *
+ * ## type
+ * The type property is a string that identifies the model type.
+ * The type is used to identify the model type in the model registry and to narrow down the model type in type predicates.  It's most frequently
+ * used when declaring dependencies on models.
+ *
+ * @example
+ * ```typescript
+ *
+ * @kosDependency({modelType: TranslationContainer.type, id: "translationContainerId"})
+ * private translationContainerModel: TranslationContainerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new TranslationContainerModel instances.
+ *
+ 
+ * As this is a singleton model, the factory function accepts the model options as its argument.
+ *
+ * If a model with the same model type already exists, the factory function will return the existing model.  The options will be ignored
+ * in this case and the existing model will be returned in its current state.
+ *
+ * @example
+ * ```typescript
+ * const model = TranslationContainer.factory({
+ *   // Add option data
+ * });
+ * ```
+ 
+
+ *
+ * ## predicate
+ *
+ * [Typescript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates) function that will identify and narrow down a model to a TranslationContainerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (TranslationContainer.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to TranslationContainerModel
+ *    // and the compiler will know that the model has the TranslationContainerModel interface
+ *    model.updateAvailability(false);
+ * }
+ * ```
+ *
+ * ## registration
+ *
+ * The registration property is an object that can be used to simplify registration of the model with the model registry.  The registration object
+ * can be spread into the model registration and provides all of the required information to register the model implementation class against the model type.
+ *
+ *
+ * @example
+ *
+ * In an application registration file you can declare the model registration as follows:
+ *
+ * **registration.ts**
+ * ```typescript
+ * import { TranslationContainer } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...TranslationContainer.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The translationContainer model is a singleton model.  This means that each time the factory function is called , the same instance will be returned.
+ * If the model does not yet exist, it will be created passing in the provided options to initialize it.
+ *
+ * Singleton models don't require an ID as they will use the model type as their ID to guarantee uniqueness throughout the system.
+ 
+ * */
+export declare const TranslationContainer: Readonly<SingletonKosModelRegistrationBean<TranslationContainerModel, TranslationContainerOptions>>;
+//# sourceMappingURL=translation-container-registration.d.ts.map