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

package/models/models/kos-expression-evaluator/kos-expression-evaluator-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-expression-evaluator-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-expression-evaluator/kos-expression-evaluator-model.ts"],"names":[],"mappings":"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"}

package/models/models/kos-expression-evaluator/services/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * KOS Expression Evaluator Services
+ *
+ * No services are exported as this is a local computation model.
+ */
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-expression-evaluator/services/index.d.ts.map

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

package/models/models/kos-expression-evaluator/services/kos-expression-evaluator-services.d.ts

@@ -0,0 +1,15 @@
+/**
+ * KOS Expression Evaluator Services
+ *
+ * The Expression Evaluator model is a purely computational model that performs
+ * local expression evaluation against context data. It does not require any
+ * HTTP services or external API calls.
+ *
+ * All functionality is self-contained within the model using:
+ * - expr-eval library for expression parsing and evaluation
+ * - KOS reactive patterns for automatic re-evaluation
+ * - Local context data storage
+ *
+ * No external services are needed.
+ */
+//# sourceMappingURL=kos-expression-evaluator-services.d.ts.map

package/models/models/kos-expression-evaluator/services/kos-expression-evaluator-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-expression-evaluator-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-expression-evaluator/services/kos-expression-evaluator-services.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/models/models/kos-expression-evaluator/types/index.d.ts

@@ -0,0 +1 @@
+export interface KosExpressionEvaluatorOptions {}

package/models/models/kos-log-manager/index.d.ts

@@ -0,0 +1,5 @@
+export { KosLogManager } from './kos-log-manager-registration';
+export type * from './types';
+export type { KosLogManagerModel } from './kos-log-manager-model';
+export * as KosLogManagerServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-log-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-log-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,qBAAqB,MAAM,YAAY,CAAC"}

package/models/models/kos-log-manager/kos-log-manager-model.d.ts

@@ -0,0 +1,139 @@
+import { KosLogManagerOptions, LogLevelDescriptor, LogOverride } from './types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+import { ApiCallbackWithWildcard } from '../../../core/core/decorators';
+import { KosRequest, KosResponse } from '../../../core';
+
+/**
+ * Model type identifier for the KOS Log Manager
+ */
+export declare const MODEL_TYPE = "kos-log-manager-model";
+/**
+ * KOS Log Manager Model - Centralized runtime log level management for the entire KOS system.
+ *
+ * This singleton model provides comprehensive control over logging behavior across the KOS UI SDK
+ * and connected applications. It manages dynamic log level overrides, responds to real-time
+ * configuration changes, and provides both REST API and WebSocket interfaces for log management.
+ * Essential for debugging, performance monitoring, and production troubleshooting.
+ *
+ * ## Key Features
+ * - **Runtime Log Level Control** - Dynamically adjust log levels without application restart
+ * - **Hierarchical Logger Management** - Apply overrides to parent loggers and all children
+ * - **Real-time Configuration** - WebSocket-based updates propagate instantly across clients
+ * - **REST API Integration** - Query and manage logger configurations via HTTP endpoints
+ * - **Override Persistence** - Log overrides are maintained across sessions and page refreshes
+ * - **Multi-Node Support** - Coordinate logging across different KOS device nodes
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to these KOS topics for real-time log management:
+ * - **`/kos/logs/override/add/*`** - Fired when new log level overrides are created
+ * - **`/kos/logs/override/remove/*`** - Fired when log level overrides are removed
+ *
+ * Both topics support wildcard capture for node type targeting, enabling precise
+ * control over which device nodes receive logging configuration changes.
+ *
+ * ## Architecture Integration
+ * The log manager integrates with the broader KOS logging ecosystem:
+ * - **KosLog System** - Manages underlying logger instances and level settings
+ * - **LogStreamModel** - Streams managed by this model's log level policies
+ * - **LogBlockModel** - Individual log entries governed by level settings
+ * - **REST Endpoints** - Provides `/api/kos/ui/loggers` for external access
+ *
+ * ## Common Use Cases
+ * - **Development Debugging** - Increase log verbosity for specific components during development
+ * - **Production Troubleshooting** - Temporarily enable debug logging to diagnose issues
+ * - **Performance Monitoring** - Adjust log levels to reduce overhead in production
+ * - **System Administration** - Centrally manage logging across distributed KOS deployments
+ * - **Dynamic Configuration** - Change logging behavior without service interruption
+ * - **Selective Logging** - Enable detailed logging for specific modules while keeping others quiet
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const logManager = KosLogManager.instance('log-control').build();
+ *
+ * // Get all current logger configurations via REST API
+ * const loggers = await logManager.getAllLoggers();
+ * console.log(`Managing ${loggers.length} loggers`);
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ * @useDeclaredType
+ *
+ * @see {@link LogStreamModel} - Streams whose content is governed by log levels managed here
+ * @see {@link LogBlockModel} - Individual log entries affected by level settings
+ * @see {@link KosLogManagerOptions} - Configuration options for the log manager
+ * @see {@link LogOverride} - Log level override structure for runtime control
+ * @see {@link LogLevelDescriptor} - Logger information structure returned by REST API
+ */
+export type KosLogManagerModel = PublicModelInterface<KosLogManagerModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class KosLogManagerModelImpl implements IKosDataModel, IKosIdentifiable {
+    id: string;
+    private logger;
+    private _overrides;
+    constructor(modelId: string, options: KosLogManagerOptions, context: KosCreationContext);
+    updateModel(_options: KosLogManagerOptions): void;
+    /**
+     * Resolves all registered loggers and their current log levels.
+     * @returns A map of logger names to their log level descriptors
+     * @private
+     */
+    private resolveLoggers;
+    /**
+     * REST API endpoint to retrieve all logger configurations.
+     * @get /api/kos/ui/loggers
+     * @param _req - The incoming request (unused)
+     * @param res - The response object to send logger data
+     * @returns Array of log level descriptors for all loggers
+     */
+    getAllLoggers(_req?: KosRequest, res?: KosResponse): Promise<LogLevelDescriptor[]>;
+    /**
+     * Applies a log level override to matching loggers.
+     * Sets the specified log level for the logger and all child loggers
+     * whose names start with the override name.
+     * @param override - The log override configuration to apply
+     * @private
+     */
+    private setLogLevels;
+    /**
+     * Resets log levels to their defaults for matching loggers.
+     * Removes the override for the logger and all child loggers
+     * whose names start with the override name.
+     * @param override - The log override configuration to reset
+     * @private
+     */
+    private resetLogLevels;
+    /**
+     * WebSocket handler for log override addition events.
+     * Listens to: /kos/logs/override/add/*
+     * @param override - The log override to add
+     * @param payload - Contains wildcard capture data including nodeType
+     */
+    handleOverrideAdded(override: LogOverride, payload: ApiCallbackWithWildcard<any>): void;
+    /**
+     * WebSocket handler for log override removal events.
+     * Listens to: /kos/logs/override/remove/*
+     * @param override - The log override to remove
+     */
+    handleOverrideRemoved(override: LogOverride): void;
+    /**
+     * Initializes the log manager model.
+     * Called during model creation lifecycle.
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * Loads existing log overrides from the server.
+     * Fetches UI-specific overrides and applies them to the current loggers.
+     * Called after model initialization.
+     * @internal
+     */
+    load(): Promise<void>;
+}
+//# sourceMappingURL=kos-log-manager-model.d.ts.map

package/models/models/kos-log-manager/kos-log-manager-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-log-manager-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-log-manager/kos-log-manager-model.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAIL,KAAK,uBAAuB,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EAElB,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,eAAO,MAAM,UAAU,0BAA0B,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AA2B9E;;;GAGG;AACH,qBACa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,MAAM,CAAmB;IAEjC,OAAO,CAAC,UAAU,CAAiC;gBAEjD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAU7B,WAAW,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAMjD;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;OAMG;IAEG,aAAa,CACjB,IAAI,CAAC,EAAE,UAAU,EACjB,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAOhC;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAwBpB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAsBtB;;;;;OAKG;IAMH,mBAAmB,CACjB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,uBAAuB,CAAC,GAAG,CAAC;IAWvC;;;;OAIG;IAMH,qBAAqB,CAAC,QAAQ,EAAE,WAAW;IAK3C;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAwB5B"}

package/models/models/kos-log-manager/kos-log-manager-registration.d.ts

@@ -0,0 +1,92 @@
+import { KosLogManagerModel } from './kos-log-manager-model';
+import { KosLogManagerOptions } from './types';
+import { SingletonKosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # KosLogManager
+ *
+ * The registration bean includes convenience methods for creating and working with KosLogManagerModel 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: KosLogManager.type, id: "kosLogManagerId"})
+ * private kosLogManagerModel: KosLogManagerModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new KosLogManagerModel 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 = KosLogManager.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 KosLogManagerModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (KosLogManager.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to KosLogManagerModel
+ *    // and the compiler will know that the model has the KosLogManagerModel 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 { KosLogManager } 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(KosLogManager);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The kosLogManager 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 KosLogManager: SingletonKosModelRegistrationFactory<KosLogManagerModel, KosLogManagerOptions>;
+//# sourceMappingURL=kos-log-manager-registration.d.ts.map

package/models/models/kos-log-manager/kos-log-manager-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-log-manager-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-log-manager/kos-log-manager-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAGL,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqFK;AACL,eAAO,MAAM,aAAa,gFAMxB,CAAC"}

package/models/models/kos-log-manager/services/index.d.ts

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

package/models/models/kos-log-manager/services/index.d.ts.map

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

package/models/models/kos-log-manager/services/kos-log-manager-services.d.ts

@@ -0,0 +1,12 @@
+import { ApiPath, ApiResponse } from '../../../utils/service';
+import { ServiceResponse } from '../../../../core';
+
+declare const SERVICE_PATH: ApiPath;
+export type KosLogManagerResponse = ApiResponse<typeof SERVICE_PATH, "get">;
+/**
+ * @category Service
+ * Retrieves the initial  kos-log-manager data.
+ */
+export declare const getLogOverrides: () => Promise<ServiceResponse<KosLogManagerResponse>>;
+export {};
+//# sourceMappingURL=kos-log-manager-services.d.ts.map

package/models/models/kos-log-manager/services/kos-log-manager-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-log-manager-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-log-manager/services/kos-log-manager-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAY,EAAE,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAO7E,QAAA,MAAM,YAAY,EAAE,OAAmC,CAAC;AAExD,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,YAAY,EAAE,KAAK,CAAC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,QACvC,gBAAgB,qBAAqB,CAAC,CAIvC,CAAC"}

package/models/models/kos-log-manager/types/index.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Configuration options for KosLogManager model instances.
+ *
+ * Currently an empty interface but reserved for future log management
+ * configuration options such as default log levels, override policies,
+ * or persistence settings.
+ *
+ * @example Basic Log Manager Configuration
+ * ```typescript
+ * const options: KosLogManagerOptions = {
+ *   // Future options will be added here
+ * };
+ *
+ * const logManager = KosLogManager.instance('log-control')
+ *   .options(options)
+ *   .build();
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface KosLogManagerOptions {}
+
+/**
+ * Standard log level names supported by the KOS logging system.
+ *
+ * These correspond to common logging levels with increasing severity:
+ * - trace: Most verbose, includes all debug information
+ * - debug: Detailed information for debugging
+ * - info: General information messages (default)
+ * - warn: Warning messages about potential issues
+ * - error: Error messages for serious problems
+ *
+ * @example Log Level Usage
+ * ```typescript
+ * const levels: LogLevelNames[] = ['trace', 'debug', 'info', 'warn', 'error'];
+ *
+ * // Set different levels for different components
+ * const productionLevel: LogLevelNames = 'warn';
+ * const developmentLevel: LogLevelNames = 'debug';
+ * const troubleshootingLevel: LogLevelNames = 'trace';
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ */
+export type LogLevelNames = "trace" | "debug" | "info" | "warn" | "error";
+
+/**
+ * Log level override configuration for runtime log management.
+ *
+ * Used to dynamically change log levels for specific loggers or logger hierarchies
+ * without requiring application restart. Overrides are applied to the target logger
+ * and all child loggers whose names start with the override name.
+ *
+ * @example Creating Log Overrides
+ * ```typescript
+ * // Enable debug logging for all models
+ * const modelDebugOverride: LogOverride = {
+ *   name: 'kos-ui-sdk.models',
+ *   level: 'debug',
+ *   type: 'UI',
+ *   id: 'models-debug'
+ * };
+ *
+ * // Enable error-only logging for performance
+ * const performanceOverride: LogOverride = {
+ *   name: 'kos-ui-sdk.services.heavy-computation',
+ *   level: 'error',
+ *   type: 'UI',
+ *   id: 'perf-override'
+ * };
+ *
+ * // Troubleshooting override for specific component
+ * const troubleshootOverride: LogOverride = {
+ *   name: 'kos-ui-sdk.models.log-stream',
+ *   level: 'trace',
+ *   type: 'UI',
+ *   id: 'log-stream-debug'
+ * };
+ * ```
+ *
+ * @example Hierarchical Override Effects
+ * ```typescript
+ * // Setting 'kos-ui-sdk' affects all child loggers:
+ * const rootOverride: LogOverride = {
+ *   name: 'kos-ui-sdk',
+ *   level: 'debug',
+ *   type: 'UI',
+ *   id: 'sdk-debug'
+ * };
+ *
+ * // This affects:
+ * // - kos-ui-sdk.models.log-stream
+ * // - kos-ui-sdk.models.log-block
+ * // - kos-ui-sdk.services.api
+ * // - kos-ui-sdk.core.events
+ * // ... and all other loggers starting with 'kos-ui-sdk'
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ */
+export interface LogOverride {
+  /**
+   * Target log level to apply to the logger and its children.
+   *
+   * All loggers whose names start with the 'name' property will
+   * be set to this level until the override is removed.
+   */
+  level: LogLevelNames;
+
+  /**
+   * Logger name or prefix to target for the override.
+   *
+   * The override applies to this exact logger name and all loggers
+   * whose names start with this string. Use hierarchical naming
+   * like 'kos-ui-sdk.models' to target groups of related loggers.
+   */
+  name: string;
+
+  /**
+   * Type of override, typically 'UI' for KOS UI SDK overrides.
+   *
+   * Used to categorize and filter overrides by their source or purpose.
+   * Different types can be managed separately.
+   */
+  type: string;
+
+  /**
+   * Unique identifier for this override.
+   *
+   * Used to track and remove specific overrides. Should be unique
+   * within the system to prevent conflicts.
+   */
+  id: string;
+}
+
+/**
+ * Logger information descriptor returned by the log manager REST API.
+ *
+ * Provides the current state of a logger including its name and active log level.
+ * Used for querying logger configurations and displaying current system state.
+ *
+ * @example Processing Logger Descriptors
+ * ```typescript
+ * // Get all loggers from the API
+ * const loggers: LogLevelDescriptor[] = await logManager.getAllLoggers();
+ *
+ * // Analyze logging configuration
+ * const debugLoggers = loggers.filter(l => l.level === 'debug');
+ * const errorOnlyLoggers = loggers.filter(l => l.level === 'error');
+ *
+ * console.log(`${debugLoggers.length} loggers in debug mode`);
+ * console.log(`${errorOnlyLoggers.length} loggers showing errors only`);
+ *
+ * // Find specific logger
+ * const streamLogger = loggers.find(l => l.name.includes('log-stream'));
+ * if (streamLogger) {
+ *   console.log(`Log stream logger level: ${streamLogger.level}`);
+ * }
+ * ```
+ *
+ * @example Building Logger Management UI
+ * ```typescript
+ * // Use descriptors to build management interfaces
+ * const LoggerList: React.FC<{ loggers: LogLevelDescriptor[] }> = ({ loggers }) => (
+ *   <div className="logger-list">
+ *     {loggers.map(logger => (
+ *       <div key={logger.name} className="logger-item">
+ *         <span className="logger-name">{logger.name}</span>
+ *         <span className={`logger-level level-${logger.level}`}>
+ *           {logger.level.toUpperCase()}
+ *         </span>
+ *       </div>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Logging
+ */
+export interface LogLevelDescriptor {
+  /**
+   * Full name of the logger.
+   *
+   * Typically follows hierarchical naming conventions like
+   * 'kos-ui-sdk.models.log-stream' or 'kos-ui-sdk.services.api'.
+   */
+  name: string;
+
+  /**
+   * Current active log level for this logger.
+   *
+   * Shows the effective level after all overrides have been applied.
+   * This is the level that determines which log messages are actually output.
+   */
+  level: LogLevelNames;
+}

package/models/models/kos-time/index.d.ts

@@ -0,0 +1,5 @@
+export type { KosTimeModel } from './kos-time-model';
+export { KosTime } from './kos-time-registration';
+export * as KosTimeServices from './services';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/kos-time/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-time/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,KAAK,eAAe,MAAM,YAAY,CAAC;AAC9C,mBAAmB,SAAS,CAAC"}

package/models/models/kos-time/kos-time-model.d.ts

@@ -0,0 +1,100 @@
+import { DateBean, KosTimeOptions, TimeBean } from './types';
+import { IKosDataModel, IKosModelLogger, KosContextLogger, KosCreationContext, PublicModelInterface } from '../../../core';
+
+export declare const MODEL_TYPE = "kos-time-model";
+/**
+ * KOS Time Model - System time management with real-time synchronization and timezone control.
+ *
+ * This singleton model provides centralized control over system time, date, and timezone settings
+ * with automatic event propagation when changes occur. Essential for applications that need to
+ * synchronize time-based operations, schedule events, or maintain consistent timestamps across
+ * the system.
+ *
+ * ## Key Features
+ * - **System Time Control** - Update system hours, minutes, and seconds programmatically
+ * - **Date Management** - Set system date including month, day, and year
+ * - **Timezone Handling** - Change and track timezone with automatic updates
+ * - **Real-time Events** - Automatic notifications when time, date, or timezone changes
+ * - **EventBus Integration** - Publishes changes to internal EventBus for UI updates
+ * - **WebSocket Sync** - Changes propagate across all connected clients
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to three KOS topics for time synchronization:
+ * - **`/kos/time/time`** - Fired when system time changes (hour/minute/second)
+ * - **`/kos/time/day`** - Fired when the date changes (day rollover or manual change)
+ * - **`/kos/time/timezone`** - Fired when timezone is updated
+ *
+ * Additionally, the model publishes to internal EventBus topics:
+ * - `TIME_CHANGE` - For UI components to react to time updates
+ * - `DAY_CHANGE` - For date-dependent UI updates
+ * - `TIMEZONE_CHANGE` - For timezone-aware components
+ *
+ * ## Common Use Cases
+ * - **System Clock Management** - Synchronize device time with server time
+ * - **Scheduled Operations** - Trigger events based on time changes
+ * - **Multi-timezone Support** - Handle devices in different time zones
+ * - **Time-based UI Updates** - Keep clocks and calendars synchronized
+ * - **Audit Logging** - Ensure consistent timestamps across the system
+ * - **Day Rollover Handling** - Reset daily counters or refresh data
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const timeModel = KosTime.instance().build();
+ *
+ * // Update system time and date
+ * await timeModel.updateSystemTime({ hour: 15, min: 45, sec: 30 });
+ * await timeModel.updateSystemDate({ month: 3, day: 15, year: 2024 });
+ * await timeModel.updateSystemTimezone('America/New_York');
+ * ```
+ *
+ * @group KOS Model
+ * @category System Integration
+ * @useDeclaredType
+ *
+ * @see {@link TimeBean} - Time value structure (hour, minute, second)
+ * @see {@link DateBean} - Date value structure (month, day, year)
+ * @see {@link KosTimeOptions} - Configuration options for time model
+ */
+export type KosTimeModel = PublicModelInterface<KosTimeModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class KosTimeModelImpl implements IKosModelLogger, IKosDataModel {
+    id: string;
+    logger: KosContextLogger;
+    timezone: string;
+    constructor(modelId: string, _options: KosTimeOptions, context: KosCreationContext);
+    /**
+     * Updates the system clock to the provided time.
+     *
+     * @param time - The time to set the system time to
+     */
+    updateSystemTime(time: TimeBean): Promise<void>;
+    /**
+     * Updates the system clock to the provided date.
+     *
+     * @param date - The date to set the system date to
+     */
+    updateSystemDate(date: DateBean): Promise<void>;
+    /**
+     * Updates the system clock to the provided timezone.
+     * @param timezone - The timezone to set the system timezone to
+     */
+    updateSystemTimezone(timezone: string): Promise<void>;
+    handleTimeChange(): void;
+    handleDayChange(): void;
+    handleTimeZoneChange(): Promise<void>;
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    private retrieveTimezone;
+    setTimezone(tz: string): void;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+}
+//# sourceMappingURL=kos-time-model.d.ts.map

package/models/models/kos-time/kos-time-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kos-time-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/kos-time/kos-time-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5E,eAAO,MAAM,UAAU,mBAAmB,CAAC;AAM3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,MAAM,YAAY,GAAG,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;AAElE;;;GAGG;AACH,qBACa,gBAAiB,YAAW,eAAe,EAAE,aAAa;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,kBAAkB;IAO7B;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,QAAQ;IAIrC;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,QAAQ;IAIrC;;;OAGG;IACG,oBAAoB,CAAC,QAAQ,EAAE,MAAM;IAK3C,gBAAgB,IAAI,IAAI;IAMxB,eAAe,IAAI,IAAI;IAMjB,oBAAoB;IAQ1B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAIb,gBAAgB;IAI9B,WAAW,CAAC,EAAE,EAAE,MAAM;IAItB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAI5B"}