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

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,68 @@
+import { StatePropertyTypes } from '../../types';
+
+
+/**
+ * Configuration options for StateProp model instances.
+ *
+ * This interface defines the configuration options for the StateProp model,
+ * specifying which state path and attribute the model should monitor for
+ * focused property access.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const deviceOnline = StateProp.instance('device-online')
+ *   .options({
+ *     path: 'device.operational.status',
+ *     attribute: 'online'
+ *   })
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category State Management
+ */
+export interface StatePropOptions {
+  /**
+   * State path to monitor, matching the StateBean path structure.
+   * Uses dot notation hierarchy corresponding to `/kos/state/{path}` WebSocket topic.
+   *
+   * @example "device.operational.status"
+   * @example "assembly.pumps.pump1"
+   * @example "system.health.metrics"
+   */
+  path: string;
+
+  /**
+   * Specific attribute name within the state path to access.
+   * This corresponds to a property key within the StateBean's properties Map.
+   *
+   * @example "online"
+   * @example "temperature"
+   * @example "flowRate"
+   * @example "active"
+   */
+  attribute: string;
+}
+
+/**
+ * State Property Model interface - manages access to a single state property.
+ *
+ * This interface represents the public API for StateProp models, providing focused
+ * access to individual properties within a StateBean through automatic dependency
+ * management and reactive value updates.
+ *
+ * @group KOS Model
+ * @category Model Interface
+ */
+export interface KosStateProp<
+  T extends StatePropertyTypes = StatePropertyTypes
+> {
+  /** Unique model identifier */
+  id: string;
+  /** State path being monitored */
+  path: string;
+  /** Specific attribute name within the state path */
+  attribute: string;
+  /** Current property value (reactive) */
+  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,23 @@
+/**
+ * @internal
+ */
+export interface StorageDeviceResponse {
+    mountDir: string;
+    removed: boolean;
+    id: string;
+    vendor: string;
+    runTimeMs: number;
+    model: string;
+    nodeId: string;
+    local: boolean;
+    label: string;
+    syspath: string;
+    deviceType?: "disk" | "partition";
+}
+/**
+ * @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;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CACnC;AACD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,wCAQ7B,CAAC"}

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

@@ -0,0 +1,318 @@
+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";
+/**
+ * StorageDeviceContainer - Manages collections of storage devices with real-time discovery.
+ *
+ * The StorageDeviceContainer model provides centralized management of multiple storage devices
+ * connected to KOS systems. It automatically discovers devices through REST API calls and
+ * maintains real-time synchronization via WebSocket topics, handling device insertion,
+ * removal, and state updates across the entire storage ecosystem.
+ *
+ * ## Key Features
+ * - **Automatic Device Discovery** - Scans and loads all available storage devices
+ * - **Real-time Synchronization** - WebSocket updates for insertion/removal events
+ * - **Collection Management** - Add, remove, and query storage device collections
+ * - **Availability Monitoring** - Track overall storage availability status
+ * - **Volume Access** - Direct access to managed storage device instances
+ * - **Parent-Child Architecture** - Proper lifecycle management for contained devices
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to these KOS topics for real-time synchronization:
+ * - **`/kos/storage`** - Storage device availability changes (insertion/removal events)
+ *   - Payload: `StorageDeviceResponse[]` - Array of current storage device states
+ *   - Triggers automatic model updates, additions, and removals
+ *   - Handles both physical device changes and mount/unmount operations
+ *
+ * ## Storage Management Operations
+ * The container provides comprehensive storage device management:
+ * - **Device Lifecycle**: Automatic creation and cleanup of StorageDevice models
+ * - **State Synchronization**: Real-time updates from system storage changes
+ * - **Collection Queries**: Access devices by ID, status, or availability
+ * - **Volume Tracking**: Monitor mounted and available storage volumes
+ *
+ * ## Common Use Cases
+ * - **Storage Management Dashboard** - Display all connected storage devices
+ * - **File Transfer Interface** - Select available storage for operations
+ * - **System Monitoring** - Track storage availability and health
+ * - **Backup Management** - Identify backup destination devices
+ * - **Multi-node Storage** - Manage distributed storage across KOS nodes
+ * - **Device Diagnostics** - Monitor storage device runtime and status
+ *
+ * @example Basic Storage Container Usage
+ * ```typescript
+ * // Create storage device container for system management
+ * const storageContainer = StorageDeviceContainer.instance('main-storage')
+ *   .options({}) // Empty configuration - behavior driven by discovery
+ *   .build();
+ *
+ * // Check overall storage availability
+ * console.log(`Storage available: ${storageContainer.isStorageInserted}`);
+ * console.log(`Total volumes: ${storageContainer.volumes.length}`);
+ *
+ * // Access individual storage devices
+ * const usbDevice = storageContainer.getModel('usb-drive-1');
+ * if (usbDevice && !usbDevice.removed) {
+ *   console.log(`USB device mounted at: ${usbDevice.mountDir}`);
+ * }
+ * ```
+ *
+ * @example Storage Device Discovery and Management
+ * ```typescript
+ * // Container automatically handles device discovery
+ * const storageManager = StorageDeviceContainer.instance('storage-mgr')
+ *   .options({})
+ *   .build();
+ *
+ * // Monitor storage changes with reactive patterns
+ * const monitorStorageChanges = () => {
+ *   // Container automatically updates via /kos/storage topic
+ *   const availableDevices = storageManager.data.filter(device =>
+ *     !device.removed && device.mountDir
+ *   );
+ *
+ *   const localDevices = availableDevices.filter(device => device.local);
+ *   const remoteDevices = availableDevices.filter(device => !device.local);
+ *
+ *   console.log(`Available storage: ${availableDevices.length} devices`);
+ *   console.log(`Local: ${localDevices.length}, Remote: ${remoteDevices.length}`);
+ *
+ *   return {
+ *     total: availableDevices.length,
+ *     local: localDevices.length,
+ *     remote: remoteDevices.length,
+ *     devices: availableDevices
+ *   };
+ * };
+ * ```
+ *
+ * @example React Storage Management Interface
+ * ```typescript
+ * const StorageManagerComponent: React.FC = kosComponent(() => {
+ *   const storageContainer = useModel(StorageDeviceContainer, 'storage-manager');
+ *
+ *   // Reactive data automatically updates via WebSocket
+ *   const availableDevices = storageContainer.volumes.filter(device =>
+ *     !device.removed && device.mountDir
+ *   );
+ *
+ *   const removedDevices = storageContainer.volumes.filter(device =>
+ *     device.removed
+ *   );
+ *
+ *   return (
+ *     <div className="storage-manager">
+ *       <div className="storage-status">
+ *         <h2>Storage Overview</h2>
+ *         <div className="status-indicator">
+ *           <span className={storageContainer.isStorageInserted ? 'online' : 'offline'}>
+ *             {storageContainer.isStorageInserted ? 'Storage Available' : 'No Storage'}
+ *           </span>
+ *         </div>
+ *         <div className="device-count">
+ *           Total Devices: {storageContainer.volumes.length}
+ *         </div>
+ *       </div>
+ *
+ *       <div className="device-sections">
+ *         <section className="available-devices">
+ *           <h3>Available Storage ({availableDevices.length})</h3>
+ *           {availableDevices.map(device => (
+ *             <StorageDeviceCard key={device.id} device={device} />
+ *           ))}
+ *         </section>
+ *
+ *         {removedDevices.length > 0 && (
+ *           <section className="removed-devices">
+ *             <h3>Recently Removed ({removedDevices.length})</h3>
+ *             {removedDevices.map(device => (
+ *               <StorageDeviceCard key={device.id} device={device} />
+ *             ))}
+ *           </section>
+ *         )}
+ *       </div>
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @example Storage Device Filtering and Queries
+ * ```typescript
+ * // Create storage container for advanced device management
+ * const storageController = StorageDeviceContainer.instance('storage-ctrl')
+ *   .options({})
+ *   .build();
+ *
+ * // Helper functions for device filtering
+ * const getStorageQueries = (container: StorageDeviceContainer) => ({
+ *   // Get all available (mounted and not removed) devices
+ *   getAvailableDevices: () =>
+ *     container.data.filter(device => !device.removed && device.mountDir),
+ *
+ *   // Get devices by specific node
+ *   getDevicesByNode: (nodeId: string) =>
+ *     container.data.filter(device => device.nodeId === nodeId),
+ *
+ *   // Get local vs remote devices
+ *   getLocalDevices: () =>
+ *     container.data.filter(device => device.local),
+ *
+ *   // Get devices by vendor
+ *   getDevicesByVendor: (vendor: string) =>
+ *     container.data.filter(device =>
+ *       device.vendor.toLowerCase().includes(vendor.toLowerCase())
+ *     ),
+ *
+ *   // Get backup-suitable devices (available with sufficient runtime)
+ *   getBackupDevices: () =>
+ *     container.data.filter(device =>
+ *       !device.removed &&
+ *       device.mountDir &&
+ *       device.runTimeMs > 300000 // More than 5 minutes runtime
+ *     ),
+ *
+ *   // Get device statistics
+ *   getStorageStats: () => {
+ *     const devices = container.data;
+ *     return {
+ *       total: devices.length,
+ *       available: devices.filter(d => !d.removed && d.mountDir).length,
+ *       removed: devices.filter(d => d.removed).length,
+ *       local: devices.filter(d => d.local).length,
+ *       remote: devices.filter(d => !d.local).length,
+ *       averageRuntime: devices.reduce((sum, d) => sum + d.runTimeMs, 0) / devices.length
+ *     };
+ *   }
+ * });
+ *
+ * // Usage examples
+ * const queries = getStorageQueries(storageController);
+ *
+ * console.log('Storage Statistics:', queries.getStorageStats());
+ * console.log('Available Devices:', queries.getAvailableDevices().length);
+ * console.log('Backup-Ready Devices:', queries.getBackupDevices().length);
+ * ```
+ *
+ * @example WebSocket Topic Synchronization
+ * ```typescript
+ * // The container automatically handles /kos/storage topic updates
+ * const storageSync = StorageDeviceContainer.instance('sync-demo')
+ *   .options({})
+ *   .build();
+ *
+ * // Topic payload structure: StorageDeviceResponse[]
+ * // Example payload when device is inserted:
+ * // [
+ * //   {
+ * //     id: "usb-drive-new",
+ * //     mountDir: "/media/usb-new",
+ * //     vendor: "Kingston",
+ * //     model: "DataTraveler",
+ * //     label: "KINGSTON_32GB",
+ * //     nodeId: "primary",
+ * //     local: true,
+ * //     removed: false,
+ * //     runTimeMs: 0,
+ * //     syspath: "/sys/devices/usb/new"
+ * //   }
+ * // ]
+ *
+ * // Container automatically:
+ * // 1. Compares payload with existing models
+ * // 2. Removes models not in payload (device unplugged)
+ * // 3. Updates existing models with new state
+ * // 4. Creates new models for discovered devices
+ * // 5. Maintains parent-child relationships
+ *
+ * // Monitor changes reactively
+ * const logStorageChanges = () => {
+ *   const currentDevices = storageSync.data.map(device => ({
+ *     id: device.id,
+ *     vendor: device.vendor,
+ *     mounted: !!device.mountDir,
+ *     removed: device.removed
+ *   }));
+ *
+ *   console.log('Current Storage State:', currentDevices);
+ * };
+ * ```
+ *
+ * @example Multi-Node Storage Architecture
+ * ```typescript
+ * // Container manages storage across distributed KOS nodes
+ * const distributedStorage = StorageDeviceContainer.instance('distributed')
+ *   .options({})
+ *   .build();
+ *
+ * // Analyze storage distribution across nodes
+ * const analyzeStorageDistribution = () => {
+ *   const nodeGroups = distributedStorage.data.reduce((groups, device) => {
+ *     const nodeId = device.nodeId;
+ *     if (!groups[nodeId]) {
+ *       groups[nodeId] = {
+ *         nodeId,
+ *         devices: [],
+ *         available: 0,
+ *         totalRuntime: 0
+ *       };
+ *     }
+ *
+ *     groups[nodeId].devices.push(device);
+ *     if (!device.removed && device.mountDir) {
+ *       groups[nodeId].available++;
+ *     }
+ *     groups[nodeId].totalRuntime += device.runTimeMs;
+ *
+ *     return groups;
+ *   }, {} as Record<string, any>);
+ *
+ *   // Display node distribution
+ *   Object.values(nodeGroups).forEach((node: any) => {
+ *     const avgRuntime = node.totalRuntime / node.devices.length;
+ *     console.log(`Node ${node.nodeId}:`);
+ *     console.log(`  Devices: ${node.devices.length}`);
+ *     console.log(`  Available: ${node.available}`);
+ *     console.log(`  Avg Runtime: ${Math.round(avgRuntime / 60000)}min`);
+ *   });
+ *
+ *   return nodeGroups;
+ * };
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Management
+ *
+ * @see {@link StorageDevice} - Individual storage device model
+ * @see {@link StorageDeviceOptions} - Configuration options for storage devices
+ * @see {@link StorageDeviceContainerOptions} - Container configuration options
+ * @see {@link StorageDeviceResponse} - API response structure for device discovery
+ */
+export type StorageDeviceContainer = PublicModelInterface<StorageDeviceContainerModelImpl>;
+export type StorageDeviceContainerModel = PublicModelInterface<StorageDeviceContainerModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6RG;AACH,MAAM,MAAM,sBAAsB,GAChC,oBAAoB,CAAC,+BAA+B,CAAC,CAAC;AAExD,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;CAiB5B"}

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"}