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

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

@@ -0,0 +1,87 @@
+import { NetworkInterfaceModel } from './network-interface-model';
+import { KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # NetworkInterface
+ *
+ * The registration bean includes convenience methods for creating and working with NetworkInterfaceModel 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: NetworkInterface.type, id: "networkInterfaceId"})
+ * private networkInterfaceModel: NetworkInterfaceModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new NetworkInterfaceModel 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 = NetworkInterface.factory("networkInterfaceId")({
+ *   // 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 NetworkInterfaceModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (NetworkInterface.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to NetworkInterfaceModel
+ *    // and the compiler will know that the model has the NetworkInterfaceModel 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 { NetworkInterface } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(NetworkInterface);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * 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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiFK;AACL,eAAO,MAAM,gBAAgB,+FAM3B,CAAC"}

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

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

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

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

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

@@ -0,0 +1,100 @@
+/**
+ * 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];
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial network-interface data.
+ */
+export declare const getNetworkInterfaces: () => Promise<NetworkInterfaceResponse>;
+export {};
+//# sourceMappingURL=network-interface-services.d.ts.map

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

@@ -0,0 +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;;;;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

@@ -0,0 +1,31 @@
+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 ---------------
+/**
+ * @internal
+ */
+export type NetworkInterfaceContainerOptions = object;

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

@@ -0,0 +1,4 @@
+export { Ota } from './ota-registration';
+export type * from './types';
+export type { OtaModel } from './ota-model';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/ota/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC"}

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

@@ -0,0 +1,105 @@
+import { OTAArtifactResponse, UpdaterItem, UpdaterOptions, UpdaterStatus } from './types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+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;
+    /** 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;
+}
+//# sourceMappingURL=ota-model.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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/ota-registration.d.ts

@@ -0,0 +1,89 @@
+import { UpdaterOptions } from './types';
+import { OtaModel } from './ota-model';
+import { SingletonKosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # Ota
+ *
+ * The registration bean includes convenience methods for creating and working with OtaModel 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: Ota.type, id: "oTAId"})
+ * private oTAModel: OtaModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new OtaModel 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 = Ota.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 OtaModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (Ota.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to OtaModel
+ *    // and the compiler will know that the model has the OtaModel 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 { Ota } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(Ota);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The oTA 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 Ota: SingletonKosModelRegistrationFactory<OtaModel, UpdaterOptions>;
+//# sourceMappingURL=ota-registration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ota-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/ota/ota-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFK;AACL,eAAO,MAAM,GAAG,gEAMd,CAAC"}

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { OTAArtifactResponse } from '../types';
+
+/**
+ * @category Service
+ * GET request to /api/kos/ota/artifacts
+ */
+export declare const getArtifacts: () => Promise<OTAArtifactResponse[] | undefined>;
+//# sourceMappingURL=ota-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ota-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/ota/services/ota-services.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAapD;;;GAGG;AACH,eAAO,MAAM,YAAY,kDAUxB,CAAC"}

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

@@ -0,0 +1,202 @@
+export type OTAStatus =
+  | "INSTALLED" // Green Check
+  | "INVALID"
+  | "MISSING"
+  | "STAGED"; // Green Half Check
+
+export interface OTAArtifactInfo {
+  hash: string;
+  identifier: string;
+  miniHash: string;
+  name?: string;
+  size: number;
+  version?: string;
+}
+
+export interface OTARequest {
+  currentSize: number;
+  downloaderActive: boolean;
+  downloaderName: string;
+  errorCount: number;
+  fileNotFoundCount: number;
+  kabId: string;
+  lastErrorReason?: string;
+  lastUpdateTime: number;
+}
+
+export interface OTAArtifactResponse {
+  artifactInfo?: OTAArtifactInfo;
+  done: boolean;
+  error?: string;
+  requests: Record<string, OTARequest>;
+  status: OTAStatus;
+}
+
+export type UpdaterStatus =
+  | "downloading"
+  | "error"
+  | "idle"
+  | "pending"
+  | "ready";
+
+export interface UpdaterItem {
+  manifest?: boolean;
+  error?: string;
+  errorCount?: number;
+  id: string;
+  label?: string;
+  name?: string;
+  progress?: number;
+  size?: number;
+  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[];
+}