@kosdev-code/kos-ui-sdk 2.0.45 → 2.0.46

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

@@ -7,297 +7,10 @@ import { IKosIdentifiable, IKosModelHolder, PublicModelInterface } from '../../.
 
 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
+ * Storage Device Container Model
+ * @category Model
  */
 export declare class StorageDeviceContainerModelImpl implements IKosIdentifiable, IKosModelHolder<StorageDeviceModel>, IKosDataModel {
     id: string;

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

@@ -1 +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"}
+{"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-model.d.ts

@@ -2,108 +2,26 @@ import { StorageDeviceOptions } from './types';
 import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../core';
 
 export declare const MODEL_TYPE = "storage-device-model";
-/**
- * StorageDevice - Manages individual USB/external storage device information and state.
- *
- * The StorageDevice model represents individual storage devices (USB drives, SD cards,
- * external drives) connected to the KOS system. It tracks device hardware information,
- * mount status, and provides access to device metadata including vendor, model, runtime
- * statistics, and file system details.
- *
- * ## Key Features
- * - **Hardware Information** - Vendor, model, and system path details
- * - **Mount Management** - Track mount directory and removal status
- * - **Runtime Statistics** - Device runtime and usage metrics
- * - **Node Awareness** - Multi-node device distribution tracking
- * - **File System Integration** - Label and mount point management
- * - **Parent-Aware Architecture** - Designed for container model management
- *
- * ## Device Properties
- * Storage devices expose comprehensive hardware and state information:
- * - **Physical Details**: vendor, model, syspath for hardware identification
- * - **Mount Information**: mountDir, label for file system access
- * - **Status Tracking**: removed flag, local/remote node distribution
- * - **Runtime Metrics**: runTimeMs for usage analytics
- *
- * ## Common Use Cases
- * - **Storage Management UI** - Display available storage devices and capacity
- * - **File Transfer Operations** - Access mount points for file operations
- * - **System Monitoring** - Track device insertion/removal events
- * - **Backup Management** - Identify backup destination devices
- * - **Multi-node Systems** - Manage storage across distributed KOS nodes
- * - **Device Diagnostics** - Runtime statistics and health monitoring
- *
- * @interface
- * @example Basic Usage
- * ```typescript
- * const usbDrive = StorageDevice.instance('usb-drive-1')
- *   .options({
- *     mountDir: '/media/usb1',
- *     vendor: 'SanDisk',
- *     model: 'Ultra USB 3.0',
- *     label: 'BACKUP_DRIVE',
- *     nodeId: 'primary',
- *     local: true,
- *     removed: false,
- *     runTimeMs: 1800000,
- *     syspath: '/sys/devices/usb1'
- *   })
- *   .build();
- *
- * // Access device properties
- * console.log(`${usbDrive.vendor} ${usbDrive.model} at ${usbDrive.mountDir}`);
- * ```
- *
- * @group KOS Model
- * @category Device Management
- * @useDeclaredType
- *
- * @see {@link StorageDeviceOptions} - Configuration options for StorageDevice instances
- * @see {@link StorageDeviceContainerModel} - Container for managing multiple storage devices
- * @see {@link StorageDeviceResponse} - API response structure for device data
- */
-export type StorageDevice = PublicModelInterface<StorageDeviceModelImpl>;
 export type StorageDeviceModel = PublicModelInterface<StorageDeviceModelImpl>;
 /**
- * @ignore
- * @internal
+ * Storage Device Model
+ * @category Model
  */
 export declare class StorageDeviceModelImpl implements IKosDataModel, IKosIdentifiable {
-    /** Unique identifier for the storage device model instance */
     id: string;
-    /** File system mount directory path where device is accessible */
     mountDir: string;
-    /** Whether the device has been physically removed from the system */
     removed: boolean;
-    /** Device manufacturer name (e.g., 'SanDisk', 'Western Digital') */
     vendor: string;
-    /** Total device runtime in milliseconds for usage tracking */
     runTimeMs: number;
-    /** Device model name or identifier (e.g., 'Ultra USB 3.0', 'My Passport') */
     model: string;
-    /** KOS node identifier where this device is connected */
     nodeId: string;
-    /** Whether the device is connected to the local node */
     local: boolean;
-    /** File system label or volume name for the device */
     label: string;
-    /** System path for hardware identification and low-level access */
     syspath: string;
-    /** Context logger for debugging and diagnostics */
     private logger;
     constructor(modelId: string, options: StorageDeviceOptions, context: KosCreationContext);
-    /**
-     * Updates the storage device model with new configuration options.
-     * @param options New configuration options to apply to the device
-     */
     updateModel(options: StorageDeviceOptions): void;
-    /**
-     * @internal
-     */
     init(): Promise<void>;
-    /**
-     * @internal
-     */
     load(): Promise<void>;
 }
 //# sourceMappingURL=storage-device-model.d.ts.map

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,MAAM,aAAa,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAEzE,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E;;;GAGG;AACH,qBAEa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAe7B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAchD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}
+{"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/types/index.d.ts

@@ -3,132 +3,18 @@ import { KosParentAware } from '../../../../core';
 
 // ---------------  StorageDevice ---------------
 
-/**
- * Configuration options for StorageDevice model instances.
- *
- * This interface defines the complete configuration structure for individual storage devices,
- * including hardware identification, mount information, and runtime metrics. These options
- * are typically populated from storage device discovery services and WebSocket updates.
- *
- * @example Basic Usage
- * ```typescript
- * const device = StorageDevice.instance('usb-backup')
- *   .options({
- *     mountDir: '/media/usb-drive',
- *     vendor: 'SanDisk',
- *     model: 'Ultra USB 3.0',
- *     label: 'BACKUP_DRIVE',
- *     nodeId: 'primary',
- *     local: true,
- *     removed: false,
- *     runTimeMs: 1800000,
- *     syspath: '/sys/devices/usb1'
- *   })
- *   .build();
- * ```
- *
- * @kosService core.storage
- * @category Model Configuration
- * @category Device Management
- */
 export interface StorageDeviceOptions extends KosParentAware {
-  /**
-   * File system mount directory path where the device is accessible.
-   * Empty string indicates the device is not currently mounted.
-   *
-   * @example "/media/usb-drive"
-   * @example "/mnt/backup-storage"
-   * @example "" // Not mounted
-   */
   mountDir: string;
-
-  /**
-   * Indicates whether the storage device has been physically removed.
-   * When true, the device is no longer accessible and mount operations will fail.
-   *
-   * @default false
-   */
   removed: boolean;
-
-  /**
-   * Hardware vendor/manufacturer name of the storage device.
-   * Used for device identification and display purposes.
-   *
-   * @example "SanDisk"
-   * @example "Western Digital"
-   * @example "Samsung"
-   */
   vendor: string;
-
-  /**
-   * Total runtime in milliseconds since the device was first connected.
-   * Tracks cumulative usage time for analytics and maintenance scheduling.
-   *
-   * @example 1800000 // 30 minutes
-   * @example 3600000 // 1 hour
-   */
   runTimeMs: number;
-
-  /**
-   * Hardware model name/number of the storage device.
-   * Combined with vendor for complete device identification.
-   *
-   * @example "Ultra USB 3.0"
-   * @example "My Passport"
-   * @example "EVO Select 64GB"
-   */
   model: string;
-
-  /**
-   * KOS node identifier where this storage device is physically connected.
-   * Used in multi-node systems to track device distribution.
-   *
-   * @example "primary"
-   * @example "secondary"
-   * @example "embedded-node-1"
-   */
   nodeId: string;
-
-  /**
-   * Indicates if the device is connected to the local node (true) or remote node (false).
-   * Determines accessibility and operation capabilities from current context.
-   *
-   * @default true
-   */
   local: boolean;
-
-  /**
-   * File system label/name assigned to the storage device.
-   * Used for user-friendly identification and mount point organization.
-   *
-   * @example "BACKUP_DRIVE"
-   * @example "CONFIG_STORAGE"
-   * @example "DATA_ARCHIVE"
-   */
   label: string;
-
-  /**
-   * System device path in the Linux device tree.
-   * Low-level hardware identifier for device tracking and diagnostics.
-   *
-   * @example "/sys/devices/pci0000:00/usb1/1-2"
-   * @example "/sys/devices/mmc0/mmc0:0001"
-   * @example "/sys/devices/platform/sdhci"
-   */
   syspath: string;
 }
 
 // ---------------  StorageDeviceContainer ---------------
 
-/**
- * Configuration options for StorageDeviceContainer model instances.
- *
- * The container model manages collections of storage devices and handles real-time
- * updates via WebSocket topics. Currently uses an empty configuration object as
- * the container's behavior is primarily driven by discovered storage devices.
- *
- * @kosService core.storage
- * @category Model Configuration
- * @category Device Management
- */
 export type StorageDeviceContainerOptions = object;

package/models/models/studio-properties/studio-properties-model.d.ts

@@ -4,94 +4,19 @@ import { IKosIdentifiable } from '../../../core/core/types';
 import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
 
 export declare const MODEL_TYPE = "studio-properties-model";
-/**
- * StudioPropertiesModel - Real-time KOS Studio properties management with WebSocket synchronization.
- *
- * This model provides centralized access to KOS Studio's runtime properties and configuration
- * values, enabling applications to access Studio-specific settings, tool states, and integration
- * parameters. Properties are synchronized in real-time via WebSocket topics, ensuring all
- * connected clients maintain consistent Studio state information.
- *
- * ## Key Features
- * - **Real-time synchronization** - Properties update automatically via `/kos/studio/properties` topic
- * - **Connection-scoped access** - Properties are specific to individual Studio VM connections
- * - **Fallback handling** - Graceful degradation with default values when Studio is unavailable
- * - **Observable properties** - Create reactive computed values for any property key
- * - **Session management** - Automatic WebSocket session lifecycle with proper cleanup
- *
- * ## Topic-Based Reactivity
- * The model listens to this KOS topic for real-time synchronization:
- * - **`/kos/studio/properties`** - Broadcasts Studio property changes with connection-specific routing
- *
- * ## Common Use Cases
- * - **Studio integration status** - Check if legacy tools or specific Studio features are enabled
- * - **Tool configuration** - Access Studio tool settings and preferences for UI adaptation
- * - **Connection management** - Track Studio connection state and properties for diagnostics
- * - **Feature flags** - Access Studio-specific feature toggles and experimental settings
- *
- * @interface
- * @example Basic Usage
- * ```typescript
- * const studioProps = StudioPropertiesModel.instance('studio-conn-1')
- *   .options({ connectionId: 'vm-connection-abc123' })
- *   .build();
- *
- * await studioProps.initializePropertiesSession();
- * const legacyToolSupport = studioProps.get('kos.studio.tool.legacy');
- * ```
- *
- * @group KOS Model
- * @category System Integration
- * @useDeclaredType
- *
- * @see {@link StudioPropertiesOptions} - Configuration options for StudioPropertiesModel instances
- */
 export type StudioPropertiesModel = PublicModelInterface<StudioPropertiesModelImpl>;
-/**
- * @ignore
- * @internal
- */
 export declare class StudioPropertiesModelImpl implements IKosDataModel, IKosIdentifiable {
-    /** Unique identifier for the model instance */
     id: string;
-    /** Studio VM connection identifier for property routing */
     connectionId: string;
-    /** WebSocket subscription cleanup function */
     private unsubscribe;
-    /** Context logger for debugging and diagnostics */
     private logger;
-    /** Observable data store for Studio properties */
     private data;
     constructor(modelId: string, options: StudioPropertiesOptions, context: KosCreationContext);
-    /**
-     * @internal
-     */
     init(): Promise<void>;
-    /**
-     * @internal
-     */
     load(): Promise<void>;
-    /**
-     * Terminates the WebSocket session for Studio properties.
-     * Cleans up subscriptions to prevent memory leaks.
-     */
     terminatePropertiesSession(): Promise<void>;
-    /**
-     * Initializes WebSocket session for real-time Studio property synchronization.
-     * Loads initial properties and subscribes to update topics.
-     */
     initializePropertiesSession(): Promise<void>;
-    /**
-     * Retrieves a Studio property value by key.
-     * @param key Property key to retrieve
-     * @returns The property value or undefined if not set
-     */
     get(key: string): any;
-    /**
-     * Creates an observable computed property for reactive updates.
-     * @param key Property key to observe
-     * @returns Observable that emits when the property changes
-     */
     createObservableProperty(key: string): import('mobx').IComputedValue<any>;
 }
 //# sourceMappingURL=studio-properties-model.d.ts.map

package/models/models/studio-properties/studio-properties-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"studio-properties-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/studio-properties-model.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAIpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAMlD;;;GAGG;AACH,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,OAAO,CAAC,WAAW,CAA6B;IAChD,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;IACjC,kDAAkD;IAClD,OAAO,CAAC,IAAI,CAA+B;gBAEzC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAW7B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;OAGG;IACG,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjD;;;OAGG;IACG,2BAA2B;IA8BjC;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB;;;;OAIG;IACH,wBAAwB,CAAC,GAAG,EAAE,MAAM;CAGrC"}
+{"version":3,"file":"studio-properties-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/studio-properties-model.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAGpD,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAMlD,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,MAAM,CAAmB;IAEjC,OAAO,CAAC,IAAI,CAA+B;gBAEzC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAWvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC;IAG3C,2BAA2B;IA8BjC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB,wBAAwB,CAAC,GAAG,EAAE,MAAM;CAGrC"}