@kosdev-code/kos-ui-sdk 2.0.41 → 2.1.1

package/models/models/network-interface/index.d.ts

@@ -1,7 +1,11 @@
+export type { NetworkInterfaceContainerModel } from './network-interface-container-model';
 export { NetworkInterfaceContainer } from './network-interface-container-registration';
+export type { NetworkInterfaceModel } from './network-interface-model';
 export { NetworkInterface } from './network-interface-registration';
 export type * from './types';
-export type { NetworkInterfaceModel } from './network-interface-model';
-export type { NetworkInterfaceContainerModel } from './network-interface-container-model';
+/**
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export * as NetworkInterfaceServices from './services';
 //# sourceMappingURL=index.d.ts.map

package/models/models/network-interface/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,YAAY,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAC1F,OAAO,KAAK,wBAAwB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAC1F,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,mBAAmB,SAAS,CAAC;AAC7B;;;GAGG;AACH,OAAO,KAAK,wBAAwB,MAAM,YAAY,CAAC"}

package/models/models/network-interface/network-interface-container-model.d.ts

@@ -3,10 +3,66 @@ import { NetworkInterfaceModel } from './network-interface-model';
 import { IKosDataModel, IKosIdentifiable, IKosModelContainer, IKosModelHolder, KosCreationContext, PublicModelInterface } from '../../../core';
 
 export declare const MODEL_TYPE = "network-interface-container-model";
+/**
+ * NetworkInterfaceContainer - Centralized management of multiple network interfaces on KOS devices.
+ *
+ * The NetworkInterfaceContainer model provides comprehensive management of all network interfaces
+ * available on a KOS device, including automatic discovery, categorization, and real-time updates.
+ * This container model is essential for applications that need to manage multiple network interfaces,
+ * build network configuration screens, or monitor overall network connectivity status.
+ *
+ * ## Key Features
+ * - **Automatic Interface Discovery** - Loads and manages all available network interfaces from the device
+ * - **Category-Based Indexing** - Organizes interfaces by category (INTERNAL, INTEGRATION, EXTERNAL, NONE)
+ * - **Real-Time Refresh** - Updates interface data with current network state
+ * - **Unified Interface Management** - Single point of access for all network interface operations
+ * - **Dynamic Interface Tracking** - Handles interface addition/removal as network state changes
+ * - **Service Integration** - Automatically fetches interface data from KOS network services
+ *
+ * ## Interface Categories
+ * The container automatically organizes interfaces into categories:
+ * - **EXTERNAL** - User-facing interfaces (WiFi adapters, Ethernet ports)
+ * - **INTERNAL** - System interfaces (loopback, virtual interfaces)
+ * - **INTEGRATION** - Integration-specific network interfaces
+ * - **NONE** - Uncategorized interfaces
+ *
+ * ## Common Use Cases
+ * - **Network Configuration UI** - Build comprehensive network settings interfaces
+ * - **System Monitoring** - Track overall network connectivity and interface health
+ * - **Interface Selection** - Allow users to choose from available network interfaces
+ * - **Network Diagnostics** - Provide detailed system-wide network interface information
+ * - **Automated Network Management** - Programmatically manage multiple interfaces
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const networkContainer = NetworkInterfaceContainer.instance('system-interfaces')
+ *   .build();
+ *
+ * // Access all network interfaces and get specific interface
+ * const allInterfaces = networkContainer.models;
+ * const ethInterface = networkContainer.getModel('eth0');
+ * ```
+ *
+ * @group KOS Model
+ * @category Network Interfaces
+ * @interface
+ * @useDeclaredType
+ *
+ * @see {@link NetworkInterface} - Individual network interface model
+ * @see {@link NetworkInterfaceOptions} - Network interface configuration options
+ * @see {@link getNetworkInterfaces} - Service function for loading interface data
+ */
 export type NetworkInterfaceContainerModel = PublicModelInterface<NetworkInterfaceContainerModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
 export declare class NetworkInterfaceContainerModelImpl implements IKosIdentifiable, IKosModelHolder<NetworkInterfaceModel>, IKosDataModel {
+    /** Unique identifier for the container model instance */
     id: string;
+    /** Context logger for debugging and network interface operations */
     private logger;
+    /** Container for managing NetworkInterface model instances with category indexing */
     private _models;
     constructor(modelId: string, options: NetworkInterfaceContainerOptions, context: KosCreationContext);
     getModel(id: string): NetworkInterfaceModel | undefined;
@@ -14,8 +70,14 @@ export declare class NetworkInterfaceContainerModelImpl implements IKosIdentifia
     get data(): NetworkInterfaceModel[];
     addModel(model: NetworkInterfaceModel): void;
     removeModel(id: string): void;
+    /**
+     * @internal
+     */
     init(): Promise<void>;
     refreshInterfaces(): Promise<void>;
+    /**
+     * @internal
+     */
     load(): Promise<void>;
 }
 //# sourceMappingURL=network-interface-container-model.d.ts.map

package/models/models/network-interface/network-interface-container-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-interface-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEf,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,UAAU,sCAAsC,CAAC;AAE9D,MAAM,MAAM,8BAA8B,GACxC,oBAAoB,CAAC,kCAAkC,CAAC,CAAC;AAE3D,qBACa,kCACX,YACE,gBAAgB,EAChB,eAAe,CAAC,qBAAqB,CAAC,EACtC,aAAa;IAEf,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACvB,OAAO,CAAC,OAAO,CAA4C;gBAEnE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,kBAAkB;IAe7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,8CAET;IACD,IAAI,IAAI,4BAEP;IAED,QAAQ,CAAC,KAAK,EAAE,qBAAqB;IAIrC,WAAW,CAAC,EAAE,EAAE,MAAM;IAKhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,iBAAiB;IAoBjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}
+{"version":3,"file":"network-interface-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-container-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEf,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,SAAS,CAAC;AAEhE,eAAO,MAAM,UAAU,sCAAsC,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,MAAM,8BAA8B,GACxC,oBAAoB,CAAC,kCAAkC,CAAC,CAAC;AAE3D;;;GAGG;AACH,qBACa,kCACX,YACE,gBAAgB,EAChB,eAAe,CAAC,qBAAqB,CAAC,EACtC,aAAa;IAEf,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAmB;IACjC,qFAAqF;IAC3E,OAAO,CAAC,OAAO,CAA4C;gBAEnE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,kBAAkB;IAe7B,QAAQ,CAAC,EAAE,EAAE,MAAM;IAGnB,IAAI,MAAM,8CAET;IACD,IAAI,IAAI,4BAEP;IAED,QAAQ,CAAC,KAAK,EAAE,qBAAqB;IAIrC,WAAW,CAAC,EAAE,EAAE,MAAM;IAKtB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,iBAAiB;IAoBvB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/models/models/network-interface/network-interface-container-registration.d.ts

@@ -80,7 +80,8 @@ import { SingletonKosModelRegistrationFactory } from '../../../core';
  * 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.
- 
+ * @group KOS Model
+ * @category Network Interfaces
  * */
 export declare const NetworkInterfaceContainer: SingletonKosModelRegistrationFactory<NetworkInterfaceContainerModel, object>;
 //# sourceMappingURL=network-interface-container-registration.d.ts.map

package/models/models/network-interface/network-interface-container-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-interface-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAQ1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,yBAAyB,8EAOlC,CAAC"}
+{"version":3,"file":"network-interface-container-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-container-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAQ1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiFK;AACL,eAAO,MAAM,yBAAyB,8EAOlC,CAAC"}

package/models/models/network-interface/network-interface-model.d.ts

@@ -3,23 +3,100 @@ import { EthernetData, Ip44Settings, NetworkInterfaceCategory, NetworkInterfaceD
 import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../core';
 
 export declare const MODEL_TYPE = "network-interface-model";
+/**
+ * NetworkInterface - Network interface management and monitoring for KOS devices.
+ *
+ * The NetworkInterface model provides comprehensive network interface management capabilities, including
+ * WiFi and Ethernet configuration, IP settings, and real-time network state monitoring. This model is
+ * essential for applications that need to display network status, configure network connections, or
+ * manage network interfaces on KOS devices.
+ *
+ * ## Key Features
+ * - **Network Interface Discovery** - Automatically discovers and tracks available network interfaces
+ * - **WiFi Management** - Access WiFi connection details, signal strength, and access point information
+ * - **Ethernet Monitoring** - Track Ethernet connection status, speed, and duplex settings
+ * - **IP Configuration** - Monitor and manage IPv4 settings including addresses, gateways, and DNS
+ * - **Connection State Tracking** - Real-time monitoring of network device states and connectivity
+ * - **Hardware Information** - Access to MAC addresses, MTU settings, and device capabilities
+ *
+ * ## Network Interface Categories
+ * The model categorizes interfaces for easier management:
+ * - **INTERNAL** - Internal system interfaces (loopback, etc.)
+ * - **INTEGRATION** - Integration-specific interfaces
+ * - **EXTERNAL** - User-facing network interfaces (WiFi, Ethernet)
+ * - **NONE** - Uncategorized interfaces
+ *
+ * ## Common Use Cases
+ * - **Network Status Display** - Show current connection status and network details in UI
+ * - **Connection Management** - Allow users to view and configure network settings
+ * - **Network Diagnostics** - Provide detailed network interface information for troubleshooting
+ * - **System Integration** - Monitor network connectivity for automated systems
+ * - **Configuration Interfaces** - Build network configuration screens with current state
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const networkInterface = NetworkInterface.instance('eth0')
+ *   .options({
+ *     name: 'eth0',
+ *     type: 'ethernet',
+ *     configured: true,
+ *     category: 'EXTERNAL'
+ *   })
+ *   .build();
+ *
+ * console.log(networkInterface.name); // 'eth0'
+ * console.log(networkInterface.configured); // true
+ * ```
+ *
+ * @group KOS Model
+ * @category Network Interfaces
+ * @useDeclaredType
+ *
+ * @see {@link NetworkInterfaceContainer} - Container model for managing multiple network interfaces
+ * @see {@link NetworkInterfaceOptions} - Configuration options interface
+ * @see {@link EthernetData} - Ethernet-specific interface data
+ * @see {@link WifiData} - WiFi-specific interface data
+ * @see {@link Ip44Settings} - IPv4 configuration settings
+ */
 export type NetworkInterfaceModel = PublicModelInterface<NetworkInterfaceModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
 export declare class NetworkInterfaceModelImpl implements IKosDataModel, IKosIdentifiable, NetworkInterfaceData {
+    /** Unique identifier for the model instance */
     id: string;
+    /** Network interface name (e.g., 'eth0', 'wlan0', 'lo') */
     name: string;
+    /** Interface type identifier (e.g., 'ethernet', 'wifi', 'loopback') */
     type: string;
+    /** NetworkManager device state code indicating connection status */
     nmdevicestate: number;
+    /** Hardware MAC address of the network interface */
     hwaddress: string;
+    /** Maximum Transmission Unit size for the interface */
     mtu: number;
+    /** Whether the interface is currently configured and active */
     configured: boolean;
+    /** WiFi-specific connection data including SSID, signal strength, and security */
     wifi?: WifiData;
+    /** Ethernet-specific connection data including carrier status, speed, and duplex */
     ethernet?: EthernetData;
+    /** IPv4 network settings including address, gateway, and DNS configuration */
     ip4settings?: Ip44Settings;
+    /** Interface categorization for organizational purposes */
     category: NetworkInterfaceCategory;
     private logger;
     constructor(modelId: string, options: NetworkInterfaceOptions, context: KosCreationContext);
     updateModel(options: NetworkInterfaceOptions): void;
+    /**
+     * @internal
+     */
     init(): Promise<void>;
+    /**
+     * @internal
+     */
     load(): Promise<void>;
 }
 //# sourceMappingURL=network-interface-model.d.ts.map

package/models/models/network-interface/network-interface-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-interface-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,oBAAoB,EACpB,QAAQ,EACT,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAEpD,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAElD,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,oBAAoB;IAEhE,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,wBAAwB,CAAC;IAEnC,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAiB7B,WAAW,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI;IAe7C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}
+{"version":3,"file":"network-interface-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,oBAAoB,EACpB,QAAQ,EACT,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAElD;;;GAGG;AACH,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB,EAAE,oBAAoB;IAEhE,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IAEX,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IAEb,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IAEb,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IAEtB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAElB,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IAEZ,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IAEpB,kFAAkF;IAClF,IAAI,CAAC,EAAE,QAAQ,CAAC;IAEhB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,YAAY,CAAC;IAExB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,YAAY,CAAC;IAE3B,2DAA2D;IAC3D,QAAQ,EAAE,wBAAwB,CAAC;IAEnC,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAiB7B,WAAW,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI;IAenD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/models/models/network-interface/network-interface-registration.d.ts

@@ -80,7 +80,8 @@ import { KosModelRegistrationFactory } from '../../../core';
  
  * The networkInterface 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.
- 
+ * @group KOS Model
+ * @category Network Interfaces
  * */
 export declare const NetworkInterface: KosModelRegistrationFactory<NetworkInterfaceModel, import('./services').NetworkInterfaceData>;
 //# sourceMappingURL=network-interface-registration.d.ts.map

package/models/models/network-interface/network-interface-registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-interface-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAOvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,gBAAgB,+FAM3B,CAAC"}
+{"version":3,"file":"network-interface-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/network-interface-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAOvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiFK;AACL,eAAO,MAAM,gBAAgB,+FAM3B,CAAC"}

package/models/models/network-interface/services/network-interface-services.d.ts

@@ -1,38 +1,92 @@
+/**
+ * Network interface categories for organizational purposes.
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export type NetworkInterfaceCategory = "INTERNAL" | "INTEGRATION" | "EXTERNAL" | "NONE";
+/**
+ * Ethernet-specific interface data including connection status and performance metrics.
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export interface EthernetData {
+    /** Whether the Ethernet cable is connected (link up/down status) */
     carrier: boolean;
+    /** Connection speed in Mbps (e.g., 10, 100, 1000) */
     speed: number;
+    /** Duplex mode - 'full' for full-duplex, 'half' for half-duplex */
     duplex: string;
 }
+/**
+ * WiFi-specific interface data including access point details and signal metrics.
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export interface WifiData {
+    /** Access Point flags indicating capabilities and features */
     apFlags: number;
+    /** BSSID (MAC address) of the connected access point */
     bssid: string;
+    /** WPA security flags for the connection */
     wpaFlags: number;
+    /** Connection bitrate in bits per second */
     bitrate: number;
+    /** Network name (Service Set Identifier) */
     ssid: string;
+    /** Signal strength percentage (0-100) */
     signal: number;
+    /** RSN (Robust Security Network) flags for WPA2/WPA3 */
     rsnFlags: number;
+    /** Time in seconds since the access point was last seen */
     lastSeenAgo: number;
+    /** WiFi frequency in MHz (e.g., 2437 for 2.4GHz, 5220 for 5GHz) */
     frequency: number;
 }
+/**
+ * IPv4 network configuration settings including addressing and DNS.
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export interface Ip44Settings {
+    /** Subnet prefix length (e.g., 24 for /24 subnet mask) */
     prefix: number;
+    /** List of address/prefix combinations in CIDR notation */
     addressprefixlist: string[];
+    /** Primary IP address assigned to the interface */
     address: string;
+    /** IP configuration method ('auto' for DHCP, 'manual' for static) */
     method: string;
+    /** Default gateway IP address for routing */
     gateway: string;
+    /** List of DNS server IP addresses */
     dnslist: string[];
 }
+/**
+ * Complete network interface data structure containing all interface properties.
+ * This is the main interface that NetworkInterfaceModel implements.
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export interface NetworkInterfaceData {
+    /** Network interface name (e.g., 'eth0', 'wlan0', 'lo') */
     name: string;
+    /** Interface type identifier (e.g., 'ethernet', 'wifi', 'loopback') */
     type: string;
+    /** NetworkManager device state code indicating connection status */
     nmdevicestate: number;
+    /** Hardware MAC address of the network interface */
     hwaddress: string;
+    /** Maximum Transmission Unit size for the interface */
     mtu: number;
+    /** Whether the interface is currently configured and active */
     configured: boolean;
+    /** WiFi-specific connection data (only present for WiFi interfaces) */
     wifi?: WifiData;
+    /** Ethernet-specific connection data (only present for Ethernet interfaces) */
     ethernet?: EthernetData;
+    /** IPv4 network settings (present when interface has IP configuration) */
     ip4settings?: Ip44Settings;
+    /** Interface categorization for organizational purposes */
     category: NetworkInterfaceCategory;
 }
 type NetworkInterfaceResponse = [error: string, data: undefined] | [error: undefined, data: NetworkInterfaceData[] | undefined];

package/models/models/network-interface/services/network-interface-services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-interface-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/services/network-interface-services.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,wBAAwB,GAChC,UAAU,GACV,aAAa,GACb,UAAU,GACV,MAAM,CAAC;AAEX,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IAEb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,wBAAwB,CAAC;CACpC;AAED,KAAK,wBAAwB,GACzB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,GAChC,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,oBAAoB,EAAE,GAAG,SAAS,CAAC,CAAC;AACjE;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB,QACrB,QAAQ,wBAAwB,CAezC,CAAC"}
+{"version":3,"file":"network-interface-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/network-interface/services/network-interface-services.ts"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAChC,UAAU,GACV,aAAa,GACb,UAAU,GACV,MAAM,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,OAAO,EAAE,OAAO,CAAC;IACjB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,uEAAuE;IACvE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,2DAA2D;IAC3D,QAAQ,EAAE,wBAAwB,CAAC;CACpC;AAED,KAAK,wBAAwB,GACzB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,GAChC,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,oBAAoB,EAAE,GAAG,SAAS,CAAC,CAAC;AACjE;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB,QACrB,QAAQ,wBAAwB,CAezC,CAAC"}

package/models/models/network-interface/types/index.d.ts

@@ -1,6 +1,27 @@
 import { NetworkInterfaceData } from '../services';
 
 
+/**
+ * Configuration options for NetworkInterface model instances.
+ *
+ * This interface defines the complete network interface configuration including hardware details,
+ * connection state, and protocol-specific information for WiFi and Ethernet interfaces.
+ * Use these options when creating NetworkInterface models to represent physical or virtual
+ * network interfaces on KOS devices.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const options: NetworkInterfaceOptions = {
+ *   name: 'eth0',
+ *   type: 'ethernet',
+ *   configured: true,
+ *   category: 'EXTERNAL'
+ * };
+ * ```
+ *
+ * @group KOS Model
+ * @category Network Interfaces
+ */
 export type NetworkInterfaceOptions = NetworkInterfaceData;
 
 // ---------------  NetworkInterfaceContainer ---------------

package/models/models/ota/ota-model.d.ts

@@ -5,20 +5,99 @@ import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
 import { IKosDataContainer } from '../../../core/core/kos-data-container';
 
 export declare const MODEL_TYPE = "ota-model";
+/**
+ * OTA - Over-the-Air update management system for KOS devices.
+ *
+ * The OTA model provides comprehensive management of software updates and artifacts on KOS devices,
+ * including real-time download progress tracking, installation management, and error handling.
+ * This model is essential for applications that need to manage software updates, display update
+ * status, and handle system maintenance operations.
+ *
+ * ## Key Features
+ * - **Real-Time Update Tracking** - Live monitoring of download progress and installation status
+ * - **Artifact Management** - Complete visibility into available and installed software artifacts
+ * - **Trouble Integration** - Integration with KOS trouble system for error tracking and resolution
+ * - **Status Monitoring** - Comprehensive status tracking (downloading, pending, ready, error, idle)
+ * - **Installation Control** - Safe installation and reboot management for pending updates
+ * - **Progress Reporting** - Detailed download progress with size and percentage completion
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to these KOS topics for real-time synchronization:
+ * - **`/kos/ota/artifacts/all`** - Complete artifact list updates from OTA service
+ * - **`/kos/ota/artifacts/changed`** - Incremental artifact status changes during downloads
+ *
+ * ## Update States
+ * - **idle** - No updates in progress, system ready
+ * - **downloading** - Updates actively downloading from remote sources
+ * - **pending** - Updates downloaded and staged, ready for installation
+ * - **ready** - Updates installed and ready for use
+ * - **error** - Update process encountered errors, intervention needed
+ *
+ * ## Common Use Cases
+ * - **Update Status Dashboard** - Display current update status and progress to users
+ * - **System Maintenance** - Manage scheduled updates and installations
+ * - **Error Handling** - Monitor and resolve update-related issues
+ * - **Progress Monitoring** - Track download progress for large artifacts
+ * - **Installation Management** - Control when updates are applied to minimize downtime
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const otaModel = Ota.instance('system-updater').build();
+ *
+ * // Access current update status and manage installations
+ * console.log(otaModel.status); // 'idle' | 'downloading' | 'pending' | 'ready' | 'error'
+ * if (otaModel.status === 'pending') {
+ *   otaModel.installAndReboot();
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category System Integration
+ * @useDeclaredType
+ *
+ * @see {@link UpdaterOptions} - Configuration options for OTA model
+ * @see {@link UpdaterItem} - Individual update artifact interface
+ * @see {@link UpdaterStatus} - Available update status types
+ * @see {@link OTAArtifactResponse} - Raw artifact data from OTA service
+ * @see {@link TroubleContainer} - Integrated trouble management system
+ */
 export type OtaModel = PublicModelInterface<OtaModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
 export declare class OtaModelImpl implements IKosDataModel, IKosIdentifiable {
+    /** Unique identifier for the model instance */
     id: string;
     private logger;
+    /** Internal data container holding all available update artifacts */
     private data;
+    /** Trouble container dependency for tracking OTA-related troubles */
     private troubleContainer;
-    get downloadInProgressTrouble(): any;
-    get updatePendingTrouble(): any;
-    get pausedDueToErrorsTrouble(): any;
+    /** Trouble condition indicating downloads are currently in progress */
+    get downloadInProgressTrouble(): import('..').TroubleModel<any>;
+    /** Trouble condition indicating updates are downloaded and pending installation */
+    get updatePendingTrouble(): import('..').TroubleModel<any>;
+    /** Trouble condition indicating OTA process is paused due to errors */
+    get pausedDueToErrorsTrouble(): import('..').TroubleModel<any>;
+    /** Collection of all available update artifacts with their current status */
     get updates(): IKosDataContainer<UpdaterItem>;
+    /** Current overall update status based on active trouble conditions */
     get status(): UpdaterStatus;
     constructor(modelId: string, options: UpdaterOptions, context: KosCreationContext);
+    /**
+     * Installs pending updates and initiates system reboot.
+     * This method resolves the OTAUpdatePendingTrouble to trigger installation.
+     */
     installAndReboot(): void;
+    /**
+     * @internal
+     */
     init(): Promise<void>;
+    /**
+     * @internal
+     */
     load(): Promise<void>;
     handleAllArtifacts(artifacts: OTAArtifactResponse[]): Promise<void>;
     handleChangedArtifacts(artifacts: OTAArtifactResponse[]): void;

package/models/models/ota/ota-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ota-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/ota/ota-model.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,uCAAuC,CAAC;AAC/C,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;AAIhE,OAAO,KAAK,EACV,mBAAmB,EAEnB,WAAW,EACX,cAAc,EACd,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,UAAU,cAAc,CAAC;AAEtC,MAAM,MAAM,QAAQ,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;AA8D1D,qBACa,YAAa,YAAW,aAAa,EAAE,gBAAgB;IAClE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAEjC,OAAO,CAAC,IAAI,CAA0D;IAGtE,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,IAAI,yBAAyB,QAQ5B;IAED,IAAI,oBAAoB,QAOvB;IAED,IAAI,wBAAwB,QAO3B;IAED,IAAI,OAAO,mCAEV;IAED,IAAI,MAAM,IAAI,aAAa,CAU1B;gBAGC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,kBAAkB;IAU7B,gBAAgB;IAcV,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBrB,kBAAkB,CAAC,SAAS,EAAE,mBAAmB,EAAE;IAoBzD,sBAAsB,CAAC,SAAS,EAAE,mBAAmB,EAAE;CAaxD"}
+{"version":3,"file":"ota-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/ota/ota-model.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,uCAAuC,CAAC;AAC/C,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;AAIhE,OAAO,KAAK,EACV,mBAAmB,EAEnB,WAAW,EACX,cAAc,EACd,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,UAAU,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,MAAM,QAAQ,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;AA8D1D;;;GAGG;AACH,qBACa,YAAa,YAAW,aAAa,EAAE,gBAAgB;IAClE,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAEjC,qEAAqE;IACrE,OAAO,CAAC,IAAI,CAA0D;IAEtE,qEAAqE;IAErE,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,uEAAuE;IACvE,IAAI,yBAAyB,mCAQ5B;IAED,mFAAmF;IACnF,IAAI,oBAAoB,mCAOvB;IAED,uEAAuE;IACvE,IAAI,wBAAwB,mCAO3B;IAED,6EAA6E;IAC7E,IAAI,OAAO,mCAEV;IAED,uEAAuE;IACvE,IAAI,MAAM,IAAI,aAAa,CAU1B;gBAGC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,kBAAkB;IAU7B;;;OAGG;IACH,gBAAgB;IAchB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBrB,kBAAkB,CAAC,SAAS,EAAE,mBAAmB,EAAE;IAoBzD,sBAAsB,CAAC,SAAS,EAAE,mBAAmB,EAAE;CAaxD"}

package/models/models/ota/types/index.d.ts

@@ -51,6 +51,152 @@ export interface UpdaterItem {
   status: UpdaterStatus;
 }
 
+/**
+ * Configuration options for OTA model instances.
+ *
+ * This interface defines the initial configuration for the OTA model, including
+ * any pre-existing artifact data that should be loaded during model initialization.
+ * In most cases, the OTA model will automatically load artifacts from the OTA service,
+ * but this option allows for pre-loading or testing scenarios.
+ *
+ * @example Basic OTA Model Creation
+ * ```typescript
+ * // Most common usage - let model load artifacts automatically
+ * const otaModel = Ota.instance('system-updates').build();
+ *
+ * // The model will automatically:
+ * // - Connect to OTA service
+ * // - Load current artifacts
+ * // - Subscribe to real-time updates
+ * ```
+ *
+ * @example Pre-loaded Artifacts (Advanced)
+ * ```typescript
+ * // Advanced usage with pre-loaded artifact data
+ * const mockArtifacts: OTAArtifactResponse[] = [
+ *   {
+ *     artifactInfo: {
+ *       identifier: 'system-update-v1.2.0',
+ *       name: 'System Update',
+ *       version: '1.2.0',
+ *       size: 52428800, // 50MB
+ *       hash: 'sha256:abc123...',
+ *       miniHash: 'abc123'
+ *     },
+ *     status: 'STAGED',
+ *     done: true,
+ *     requests: {
+ *       'primary': {
+ *         currentSize: 52428800,
+ *         downloaderActive: false,
+ *         downloaderName: 'system-updater',
+ *         errorCount: 0,
+ *         fileNotFoundCount: 0,
+ *         kabId: 'system-update-v1.2.0',
+ *         lastUpdateTime: Date.now()
+ *       }
+ *     }
+ *   }
+ * ];
+ *
+ * const options: UpdaterOptions = {
+ *   otaArtifactResponse: mockArtifacts
+ * };
+ *
+ * const otaModel = Ota.instance('preloaded-updater')
+ *   .options(options)
+ *   .build();
+ * ```
+ *
+ * @example Testing Scenarios
+ * ```typescript
+ * // Create OTA model with test data for different scenarios
+ * const createTestOtaModel = (scenario: 'downloading' | 'pending' | 'error') => {
+ *   const testArtifacts: OTAArtifactResponse[] = [];
+ *
+ *   switch (scenario) {
+ *     case 'downloading':
+ *       testArtifacts.push({
+ *         artifactInfo: {
+ *           identifier: 'app-update-v2.1.0',
+ *           name: 'Application Update',
+ *           version: '2.1.0',
+ *           size: 104857600, // 100MB
+ *           hash: 'sha256:def456...',
+ *           miniHash: 'def456'
+ *         },
+ *         status: 'MISSING',
+ *         done: false,
+ *         requests: {
+ *           'primary': {
+ *             currentSize: 31457280, // 30MB downloaded
+ *             downloaderActive: true,
+ *             downloaderName: 'app-updater',
+ *             errorCount: 0,
+ *             fileNotFoundCount: 0,
+ *             kabId: 'app-update-v2.1.0',
+ *             lastUpdateTime: Date.now()
+ *           }
+ *         }
+ *       });
+ *       break;
+ *
+ *     case 'pending':
+ *       testArtifacts.push({
+ *         artifactInfo: {
+ *           identifier: 'security-patch-v1.0.1',
+ *           name: 'Security Patch',
+ *           version: '1.0.1',
+ *           size: 10485760, // 10MB
+ *           hash: 'sha256:ghi789...',
+ *           miniHash: 'ghi789'
+ *         },
+ *         status: 'STAGED',
+ *         done: true,
+ *         requests: {
+ *           'primary': {
+ *             currentSize: 10485760,
+ *             downloaderActive: false,
+ *             downloaderName: 'security-updater',
+ *             errorCount: 0,
+ *             fileNotFoundCount: 0,
+ *             kabId: 'security-patch-v1.0.1',
+ *             lastUpdateTime: Date.now()
+ *           }
+ *         }
+ *       });
+ *       break;
+ *
+ *     case 'error':
+ *       testArtifacts.push({
+ *         status: 'INVALID',
+ *         done: false,
+ *         error: 'Checksum verification failed',
+ *         requests: {
+ *           'primary': {
+ *             currentSize: 0,
+ *             downloaderActive: false,
+ *             downloaderName: 'failed-updater',
+ *             errorCount: 3,
+ *             fileNotFoundCount: 0,
+ *             kabId: 'failed-update-v1.0.0',
+ *             lastUpdateTime: Date.now(),
+ *             lastErrorReason: 'Checksum verification failed'
+ *           }
+ *         }
+ *       });
+ *       break;
+ *   }
+ *
+ *   return Ota.instance(`test-${scenario}`)
+ *     .options({ otaArtifactResponse: testArtifacts })
+ *     .build();
+ * };
+ * ```
+ *
+ * @category Model Configuration
+ * @category System Integration
+ */
 export interface UpdaterOptions {
   otaArtifactResponse: OTAArtifactResponse[];
 }