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

package/models/models/log-stream/log-stream-model.d.ts

@@ -0,0 +1,93 @@
+import { LogStreamOptions } from './types';
+import { LogBlockType } from '../log-block';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, IKosVisitor, KosCreationContext } from '../../../core/core/kosModel';
+
+export declare const MODEL_TYPE = "log-stream-model";
+/**
+ * Log Stream Model - Real-time streaming log viewer with efficient block-based management and async iteration.
+ *
+ * This model provides high-performance log streaming capabilities for monitoring KOS device logs in real-time.
+ * It organizes log data into efficient blocks for memory management and provides async iterator support
+ * for continuous log consumption. Essential for debugging, monitoring, and troubleshooting KOS applications.
+ *
+ * ## Key Features
+ * - **Real-time Log Streaming** - Live log updates as they are generated on the device
+ * - **Block-based Management** - Efficient memory usage through log block organization
+ * - **Async Iterator Support** - Stream logs using modern async/await patterns
+ * - **Subscription Control** - Subscribe/unsubscribe to specific log streams
+ * - **Line Number Tracking** - Maintains accurate line numbering across blocks
+ * - **Multi-stream Support** - Handle multiple log streams simultaneously through container model
+ *
+ * ## Common Use Cases
+ * - **Development Debugging** - Monitor application logs during development
+ * - **Production Monitoring** - Track system health and errors in deployed applications
+ * - **Troubleshooting** - Analyze log patterns to diagnose issues
+ * - **Log Analysis** - Process log streams for metrics and insights
+ * - **Real-time Dashboards** - Display live log feeds in monitoring interfaces
+ * - **Automated Log Processing** - Stream logs to external analysis tools
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const logStream = LogStream.instance('application-logs')
+ *   .options({ name: 'application-logs', nodeId: 'primary' })
+ *   .build();
+ *
+ * await logStream.subscribe();
+ * const iterator = logStream.start();
+ * for await (const logLine of iterator) {
+ *   console.log(`[LOG] ${logLine}`);
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ * @useDeclaredType
+ *
+ * @see {@link LogStreamOptions} - Configuration options for log stream instances
+ * @see {@link LogStreamContainerModel} - Container model for managing multiple streams
+ * @see {@link LogBlockModel} - Individual log block management within streams
+ */
+export type LogStreamModel = PublicModelInterface<LogStreamModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class LogStreamModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    nodeId: string;
+    private _blocks;
+    name: string;
+    currentBlockId: string;
+    isResetting: boolean;
+    constructor(modelId: string, options: LogStreamOptions, context: KosCreationContext);
+    get firstLineNum(): number;
+    get currentBlock(): import('../log-block').LogBlockModel | undefined;
+    get populated(): import('../log-block').LogBlockModel[];
+    get blocks(): import('../log-block').LogBlockModel[];
+    get totalLineCount(): number;
+    accept(visitor: IKosVisitor<IKosDataModel>): void;
+    updateBlock(blockData: LogBlockType): void;
+    addBlock(blockData: LogBlockType): void;
+    removeBlock(blockNum: number): void;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    reset(): Promise<void>;
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+    private generatorInstance?;
+    private shouldStop;
+    start(): AsyncGenerator<string, void, void>;
+    stop(): void;
+    streamLogs(): AsyncGenerator<string, void, void>;
+}
+//# sourceMappingURL=log-stream-model.d.ts.map

package/models/models/log-stream/log-stream-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-model.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EAEX,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;AACtE;;;GAGG;AACH,qBACa,kBAAmB,YAAW,aAAa,EAAE,gBAAgB;IACxE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IACjC,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,OAAO,CAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;gBAEnB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAa7B,IAAI,YAAY,WAGf;IACD,IAAI,YAAY,qDAIf;IAED,IAAI,SAAS,2CAEZ;IACD,IAAI,MAAM,2CAET;IAED,IAAI,cAAc,WAEjB;IAED,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,aAAa,CAAC;IAI1C,WAAW,CAAC,SAAS,EAAE,YAAY;IAgCnC,QAAQ,CAAC,SAAS,EAAE,YAAY;IAwBhC,WAAW,CAAC,QAAQ,EAAE,MAAM;IAGtB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB3B,OAAO,CAAC,iBAAiB,CAAC,CAAqC;IAC/D,OAAO,CAAC,UAAU,CAAS;IAE3B,KAAK;IAML,IAAI;IAKG,UAAU,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;CAgExD"}

package/models/models/log-stream/log-stream-registration.d.ts

@@ -0,0 +1,87 @@
+import { LogStreamModel } from './log-stream-model';
+import { LogStreamOptions } from './types';
+import { KosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # LogStream
+ *
+ * The registration bean includes convenience methods for creating and working with LogStreamModel 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: LogStream.type, id: "logStreamId"})
+ * private logStreamModel: LogStreamModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new LogStreamModel 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 = LogStream.factory("logStreamId")({
+ *   // 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 LogStreamModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (LogStream.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to LogStreamModel
+ *    // and the compiler will know that the model has the LogStreamModel 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 { LogStream } 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(LogStream);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The logStream model is NOT a singleton model.  This means that each time the factory function is called with a unique ID, a new model instance will be created.
+ * If the factory function is called with an ID that already exists, the existing model will be returned.
+ 
+ * */
+export declare const LogStream: KosModelRegistrationFactory<LogStreamModel, LogStreamOptions>;
+//# sourceMappingURL=log-stream-registration.d.ts.map

package/models/models/log-stream/log-stream-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/log-stream-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,SAAS,+DAMpB,CAAC"}

package/models/models/log-stream/services/index.d.ts

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

package/models/models/log-stream/services/index.d.ts.map

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

package/models/models/log-stream/services/log-stream-services.d.ts

@@ -0,0 +1,23 @@
+import { LogLinesType } from '../../log-block';
+import { ApiPath, KosApi } from '../../../utils/service';
+import { ClientResponse, DeepRequired, ElementType, ServiceResponse } from '../../../../core';
+
+export declare const getKosConnectionId: () => string | undefined;
+declare const SERVICE_PATH: ApiPath;
+export type LogStreamContainerClientResponse = ClientResponse<KosApi, typeof SERVICE_PATH, "get">;
+export type LogStreamContainerResponse = DeepRequired<ElementType<LogStreamContainerClientResponse>>;
+/**
+ * @group KOS Model
+ * @category Device Logging
+ * Retrieves the initial list of  log-stream-container data.
+ */
+export declare const getLogStreams: () => Promise<ServiceResponse<LogStreamContainerClientResponse>>;
+export declare const subscribeToLogStream: (stream: string, nodeId?: string) => Promise<void>;
+export declare const unsubscribeFromLogStream: (stream: string) => Promise<void>;
+export declare const createOverride: () => Promise<void>;
+declare const SERVICE_BLOCKS_PATH: ApiPath;
+export type LogStreamBlocksClientResponse = ClientResponse<KosApi, typeof SERVICE_BLOCKS_PATH, "get">;
+export declare const getLogStreamBlocks: (stream: string) => Promise<ServiceResponse<LogStreamBlocksClientResponse>>;
+export declare const getLogStreamBlock: (stream: string, blockId: number) => Promise<ServiceResponse<LogLinesType>>;
+export {};
+//# sourceMappingURL=log-stream-services.d.ts.map

package/models/models/log-stream/services/log-stream-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-stream-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/log-stream/services/log-stream-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAE1B,OAAY,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAOpD,eAAO,MAAM,kBAAkB,QAAO,MAAM,GAAG,SAQ9C,CAAC;AAIF,QAAA,MAAM,YAAY,EAAE,OAA+C,CAAC;AACpE,MAAM,MAAM,gCAAgC,GAAG,cAAc,CAC3D,MAAM,EACN,OAAO,YAAY,EACnB,KAAK,CACN,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,YAAY,CACnD,WAAW,CAAC,gCAAgC,CAAC,CAC9C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAAa,QACrC,gBAAgB,gCAAgC,CAAC,CAclD,CAAC;AAEF,eAAO,MAAM,oBAAoB,WACvB,MAAM,sBAEb,QAAQ,IAAI,CAcd,CAAC;AAEF,eAAO,MAAM,wBAAwB,WAC3B,MAAM,KACb,QAAQ,IAAI,CASd,CAAC;AAEF,eAAO,MAAM,cAAc,QAAa,QAAQ,IAAI,CAcnD,CAAC;AAEF,QAAA,MAAM,mBAAmB,EAAE,OACoB,CAAC;AAChD,MAAM,MAAM,6BAA6B,GAAG,cAAc,CACxD,MAAM,EACN,OAAO,mBAAmB,EAC1B,KAAK,CACN,CAAC;AAEF,eAAO,MAAM,kBAAkB,WACrB,MAAM,KACb,QAAQ,gBAAgB,6BAA6B,CAAC,CAcxD,CAAC;AAEF,eAAO,MAAM,iBAAiB,WACpB,MAAM,WACL,MAAM,KACd,QAAQ,gBAAgB,YAAY,CAAC,CAevC,CAAC"}

package/models/models/log-stream/types/index.d.ts

@@ -0,0 +1,86 @@
+// ---------------  LogStream ---------------
+
+/**
+ * Configuration options for LogStream model instances.
+ * 
+ * These options specify the log stream identity and source location for connecting
+ * to specific log streams on KOS devices.
+ *
+ * @example Basic Log Stream Configuration
+ * ```typescript
+ * const options: LogStreamOptions = {
+ *   name: 'application-logs',
+ *   nodeId: 'primary'
+ * };
+ * 
+ * const logStream = LogStream.instance('app-logger')
+ *   .options(options)
+ *   .build();
+ * ```
+ *
+ * @example Multiple Stream Types
+ * ```typescript
+ * // System logs from primary node
+ * const systemLogs = LogStream.instance('system')
+ *   .options({ name: 'system-logs', nodeId: 'primary' })
+ *   .build();
+ *
+ * // Error logs from secondary node
+ * const errorLogs = LogStream.instance('errors') 
+ *   .options({ name: 'error-logs', nodeId: 'secondary' })
+ *   .build();
+ *
+ * // Debug logs from development node
+ * const debugLogs = LogStream.instance('debug')
+ *   .options({ name: 'debug-logs', nodeId: 'dev-node' })
+ *   .build();
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ */
+export interface LogStreamOptions {
+  /**
+   * Name of the log stream to connect to.
+   * 
+   * This should match the log stream name available on the target device.
+   * Common stream names include 'application-logs', 'system-logs', 'error-logs'.
+   */
+  name: string;
+  
+  /**
+   * Node identifier where the log stream is located.
+   * 
+   * Specifies which KOS device node contains the target log stream.
+   * Typically 'primary' for main device logs, but can be any valid node ID.
+   * 
+   * @default 'primary'
+   */
+  nodeId: string;
+}
+
+// ---------------  LogStreamContainer ---------------
+
+/**
+ * Configuration options for LogStreamContainer model instances.
+ * 
+ * Currently an empty interface but reserved for future container-level
+ * configuration options such as stream filtering, automatic discovery settings,
+ * or performance tuning parameters.
+ *
+ * @example Basic Container Configuration
+ * ```typescript
+ * const options: LogStreamContainerOptions = {
+ *   // Future options will be added here
+ * };
+ * 
+ * const container = LogStreamContainer.instance('log-manager')
+ *   .options(options)
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category Data Persistence  
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LogStreamContainerOptions {}

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,83 @@
+import { NetworkInterfaceContainerOptions } from './types';
+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;
+    get models(): IKosModelContainer<NetworkInterfaceModel>;
+    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

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

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

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

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

@@ -0,0 +1,102 @@
+import { NetworkInterfaceOptions } from './types';
+import { EthernetData, Ip44Settings, NetworkInterfaceCategory, NetworkInterfaceData, WifiData } from './services';
+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

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